Page MenuHomeFreeBSD
Files F82635917

No OneTemporary
Actions

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.
diff --git a/Makefile.inc1 b/Makefile.inc1
index e3081594ec77..5aaa9a414473 100644
--- a/Makefile.inc1
+++ b/Makefile.inc1
@@ -1,3590 +1,3589 @@
#
# $FreeBSD$
#
# Make command line options:
# -DNO_CLEANDIR run ${MAKE} clean, instead of ${MAKE} cleandir
# -DNO_CLEAN do not clean at all
# -DDB_FROM_SRC use the user/group databases in src/etc instead of
# the system database when installing.
# -DNO_SHARE do not go into share subdir
# -DKERNFAST define NO_KERNEL{CONFIG,CLEAN,OBJ}
# -DNO_KERNELCONFIG do not run config in ${MAKE} buildkernel
# -DNO_KERNELCLEAN do not run ${MAKE} clean in ${MAKE} buildkernel
# -DNO_KERNELOBJ do not run ${MAKE} obj in ${MAKE} buildkernel
# -DNO_ROOT install without using root privilege
# -DWITHOUT_CTF do not run the DTrace CTF conversion tools on built objects
# LOCAL_DIRS="list of dirs" to add additional dirs to the SUBDIR list
# LOCAL_ITOOLS="list of tools" to add additional tools to the ITOOLS list
# LOCAL_LIB_DIRS="list of dirs" to add additional dirs to libraries target
# LOCAL_MTREE="list of mtree files" to process to allow local directories
# to be created before files are installed
# LOCAL_LEGACY_DIRS="list of dirs" to add additional dirs to the legacy
# target
# LOCAL_BSTOOL_DIRS="list of dirs" to add additional dirs to the
# bootstrap-tools target
# LOCAL_TOOL_DIRS="list of dirs" to add additional dirs to the build-tools
# target
# LOCAL_XTOOL_DIRS="list of dirs" to add additional dirs to the
# cross-tools target
# METALOG="path to metadata log" to write permission and ownership
# when NO_ROOT is set. (default: ${DESTDIR}/${DISTDIR}/METALOG,
# check /etc/make.conf for DISTDIR)
# TARGET="machine" to crossbuild world for a different machine type
# TARGET_ARCH= may be required when a TARGET supports multiple endians
# BUILDENV_SHELL= shell to launch for the buildenv target (def:${SHELL})
# WORLD_FLAGS= additional flags to pass to make(1) during buildworld
# KERNEL_FLAGS= additional flags to pass to make(1) during buildkernel
# SUBDIR_OVERRIDE="list of dirs" to build rather than everything.
# All libraries and includes, and some build tools will still build.
#
# The intended user-driven targets are:
# buildworld - rebuild *everything*, including glue to help do upgrades
# installworld- install everything built by "buildworld"
# checkworld - run test suite on installed world
# doxygen - build API documentation of the kernel
#
# Standard targets (not defined here) are documented in the makefiles in
# /usr/share/mk. These include:
# obj depend all install clean cleandepend cleanobj
.if !defined(TARGET) || !defined(TARGET_ARCH)
.error Both TARGET and TARGET_ARCH must be defined.
.endif
.if make(showconfig) || make(test-system-*)
_MKSHOWCONFIG= t
.endif
SRCDIR?= ${.CURDIR}
LOCALBASE?= /usr/local
TIME_ENV ?= time env
.include "share/mk/src.tools.mk"
# Cross toolchain changes must be in effect before bsd.compiler.mk
# so that gets the right CC, and pass CROSS_TOOLCHAIN to submakes.
.if defined(CROSS_TOOLCHAIN)
.if exists(${LOCALBASE}/share/toolchains/${CROSS_TOOLCHAIN}.mk)
.include "${LOCALBASE}/share/toolchains/${CROSS_TOOLCHAIN}.mk"
.elif exists(/usr/share/toolchains/${CROSS_TOOLCHAIN}.mk)
.include "/usr/share/toolchains/${CROSS_TOOLCHAIN}.mk"
.elif exists(${CROSS_TOOLCHAIN})
.include "${CROSS_TOOLCHAIN}"
.else
.error CROSS_TOOLCHAIN ${CROSS_TOOLCHAIN} not found
.endif
CROSSENV+=CROSS_TOOLCHAIN="${CROSS_TOOLCHAIN}"
.endif
.if defined(CROSS_TOOLCHAIN_PREFIX)
CROSS_COMPILER_PREFIX?=${CROSS_TOOLCHAIN_PREFIX}
.endif
XCOMPILERS= CC CXX CPP
.for COMPILER in ${XCOMPILERS}
.if defined(CROSS_COMPILER_PREFIX)
X${COMPILER}?= ${CROSS_COMPILER_PREFIX}${${COMPILER}}
.else
X${COMPILER}?= ${${COMPILER}}
.endif
.endfor
# If a full path to an external cross compiler is given, don't build
# a cross compiler.
.if ${XCC:N${CCACHE_BIN}:M/*}
MK_CLANG_BOOTSTRAP= no
# Make sure sub-makes see the option as disabled so the hack in bsd.sys.mk to
# work around incompatible headers in Clang's resource directory is enabled.
.MAKEOVERRIDES+= MK_CLANG_BOOTSTRAP
.endif
# Pull in compiler metadata from buildworld/toolchain if possible to avoid
# running CC from bsd.compiler.mk.
.if make(installworld) || make(install) || make(distributeworld) || \
make(stageworld)
.-include "${OBJTOP}/toolchain-metadata.mk"
.if !defined(_LOADED_TOOLCHAIN_METADATA)
.error A build is required first. You may have the wrong MAKEOBJDIRPREFIX set.
.endif
.endif
# Pull in COMPILER_TYPE and COMPILER_FREEBSD_VERSION early. Pull it from the
# tree to be friendlier to foreign OS builds. It's safe to do so unconditionally
# here since we will always have the right make, unlike in src/Makefile
# Don't include bsd.linker.mk yet until XBINUTILS is handled (after src.opts.mk)
_NO_INCLUDE_LINKERMK= t
# We also want the X_COMPILER* variables if we are using an external toolchain.
_WANT_TOOLCHAIN_CROSS_VARS= t
.include "share/mk/bsd.compiler.mk"
.undef _NO_INCLUDE_LINKERMK
.undef _WANT_TOOLCHAIN_CROSS_VARS
# src.opts.mk depends on COMPILER_FEATURES
.include "share/mk/src.opts.mk"
.if ${TARGET} == ${MACHINE}
TARGET_CPUTYPE?=${CPUTYPE}
.else
TARGET_CPUTYPE?=
.endif
.if !empty(TARGET_CPUTYPE)
_TARGET_CPUTYPE=${TARGET_CPUTYPE}
.else
_TARGET_CPUTYPE=dummy
.endif
.if ${TARGET} == "arm"
.if ${TARGET_ARCH:Marmv[67]*} != "" && ${TARGET_CPUTYPE:M*soft*} == ""
TARGET_ABI= gnueabihf
.else
TARGET_ABI= gnueabi
.endif
.endif
MACHINE_ABI?= unknown
MACHINE_TRIPLE?=${MACHINE_ARCH:S/amd64/x86_64/:C/sf$//}-${MACHINE_ABI}-freebsd${OS_REVISION}
TARGET_ABI?= unknown
TARGET_TRIPLE?= ${TARGET_ARCH:S/amd64/x86_64/:C/sf$//}-${TARGET_ABI}-freebsd${OS_REVISION}
KNOWN_ARCHES?= aarch64/arm64 \
amd64 \
armv6/arm \
armv7/arm \
i386 \
powerpc \
powerpc64/powerpc \
powerpc64le/powerpc \
powerpcspe/powerpc \
riscv64/riscv \
riscv64sf/riscv
.if ${TARGET} == ${TARGET_ARCH}
_t= ${TARGET}
.else
_t= ${TARGET_ARCH}/${TARGET}
.endif
.for _t in ${_t}
.if empty(KNOWN_ARCHES:M${_t})
.error Unknown target ${TARGET_ARCH}:${TARGET}.
.endif
.endfor
.if ${.MAKE.OS} != "FreeBSD"
CROSSBUILD_HOST=${.MAKE.OS}
.if ${.MAKE.OS} != "Linux" && ${.MAKE.OS} != "Darwin"
.warning Unsupported crossbuild system: ${.MAKE.OS}. Build will probably fail!
.endif
# We need to force NO_ROOT/DB_FROM_SRC builds when building on other operating
# systems since the BSD.foo.dist specs contain users and groups that do not
# exist by default on a Linux/MacOS system.
NO_ROOT:= 1
DB_FROM_SRC:= 1
.export NO_ROOT
.endif
# If all targets are disabled for system llvm then don't expect it to work
# for cross-builds.
.if !defined(TOOLS_PREFIX) && ${MK_LLVM_TARGET_ALL} == "no" && \
${MACHINE} != ${TARGET} && ${MACHINE_ARCH} != ${TARGET_ARCH} && \
!make(showconfig)
MK_SYSTEM_COMPILER= no
MK_SYSTEM_LINKER= no
.endif
# Handle external binutils.
.if defined(CROSS_TOOLCHAIN_PREFIX)
CROSS_BINUTILS_PREFIX?=${CROSS_TOOLCHAIN_PREFIX}
.endif
XBINUTILS= AS AR ELFCTL LD NM OBJCOPY RANLIB SIZE STRINGS STRIPBIN
.for BINUTIL in ${XBINUTILS}
.if defined(CROSS_BINUTILS_PREFIX) && \
exists(${CROSS_BINUTILS_PREFIX}/${${BINUTIL}})
X${BINUTIL}?= ${CROSS_BINUTILS_PREFIX:C,/*$,,}/${${BINUTIL}}
.else
X${BINUTIL}?= ${${BINUTIL}}
.endif
.endfor
# If a full path to an external linker is given, don't build lld.
.if ${XLD:M/*}
MK_LLD_BOOTSTRAP= no
.endif
# We also want the X_LINKER* variables if we are using an external toolchain.
_WANT_TOOLCHAIN_CROSS_VARS= t
.include "share/mk/bsd.linker.mk"
.undef _WANT_TOOLCHAIN_CROSS_VARS
# Begin WITH_SYSTEM_COMPILER / WITH_SYSTEM_LD
# WITH_SYSTEM_COMPILER - Pull in needed values and make a decision.
# Check if there is a local compiler that can satisfy as an external compiler.
# Which compiler is expected to be used?
.if ${MK_CLANG_BOOTSTRAP} == "yes"
WANT_COMPILER_TYPE= clang
.else
WANT_COMPILER_TYPE=
.endif
.if !defined(WANT_COMPILER_FREEBSD_VERSION) && !make(showconfig) && \
!make(test-system-linker)
.if ${WANT_COMPILER_TYPE} == "clang"
WANT_COMPILER_FREEBSD_VERSION_FILE= lib/clang/freebsd_cc_version.h
WANT_COMPILER_FREEBSD_VERSION!= \
awk '$$2 == "FREEBSD_CC_VERSION" {printf("%d\n", $$3)}' \
${SRCDIR}/${WANT_COMPILER_FREEBSD_VERSION_FILE} || echo unknown
WANT_COMPILER_VERSION_FILE= lib/clang/include/clang/Basic/Version.inc
WANT_COMPILER_VERSION!= \
awk '$$2 == "CLANG_VERSION" {split($$3, a, "."); print a[1] * 10000 + a[2] * 100 + a[3]}' \
${SRCDIR}/${WANT_COMPILER_VERSION_FILE} || echo unknown
.endif
.export WANT_COMPILER_FREEBSD_VERSION WANT_COMPILER_VERSION
.endif # !defined(WANT_COMPILER_FREEBSD_VERSION)
# It needs to be the same revision as we would build for the bootstrap.
# If the expected vs CC is different then we can't skip.
# GCC cannot be used for cross-arch yet. For clang we pass -target later if
# TARGET_ARCH!=MACHINE_ARCH.
.if ${MK_SYSTEM_COMPILER} == "yes" && \
defined(WANT_COMPILER_FREEBSD_VERSION) && \
${MK_CLANG_BOOTSTRAP} == "yes" && \
!make(xdev*) && \
${X_COMPILER_TYPE} == ${WANT_COMPILER_TYPE} && \
(${X_COMPILER_TYPE} == "clang" || ${TARGET_ARCH} == ${MACHINE_ARCH}) && \
${X_COMPILER_VERSION} == ${WANT_COMPILER_VERSION} && \
${X_COMPILER_FREEBSD_VERSION} == ${WANT_COMPILER_FREEBSD_VERSION}
# Everything matches, disable the bootstrap compiler.
MK_CLANG_BOOTSTRAP= no
USING_SYSTEM_COMPILER= yes
.endif # ${WANT_COMPILER_TYPE} == ${COMPILER_TYPE}
# WITH_SYSTEM_LD - Pull in needed values and make a decision.
# Check if there is a local linker that can satisfy as an external linker.
# Which linker is expected to be used?
.if ${MK_LLD_BOOTSTRAP} == "yes"
WANT_LINKER_TYPE= lld
.else
WANT_LINKER_TYPE=
.endif
.if !defined(WANT_LINKER_FREEBSD_VERSION) && !make(showconfig) && \
!make(test-system-compiler)
.if ${WANT_LINKER_TYPE} == "lld"
-WANT_LINKER_FREEBSD_VERSION_FILE= lib/clang/include/VCSVersion.inc
-_WANT_LINKER_FREEBSD_VERSION!= \
- awk '$$2 == "LLD_REVISION" {gsub(/"/, "", $$3); print $$3}' \
+WANT_LINKER_FREEBSD_VERSION_FILE= lib/clang/include/lld/Common/Version.inc
+WANT_LINKER_FREEBSD_VERSION!= \
+ awk '$$2 == "LLD_FREEBSD_VERSION" {print $$3}' \
${SRCDIR}/${WANT_LINKER_FREEBSD_VERSION_FILE} || echo unknown
-WANT_LINKER_FREEBSD_VERSION=${_WANT_LINKER_FREEBSD_VERSION:C/.*-(.*)/\1/}
WANT_LINKER_VERSION_FILE= lib/clang/include/lld/Common/Version.inc
WANT_LINKER_VERSION!= \
- awk '$$2 == "LLD_VERSION_STRING" { gsub("\"", "", $$3); split($$3, a, "."); print a[1] * 10000 + a[2] * 100 + a[3]}' \
+ awk '$$2 == "LLD_VERSION_STRING" {gsub("\"", "", $$3); split($$3, a, "."); print a[1] * 10000 + a[2] * 100 + a[3]}' \
${SRCDIR}/${WANT_LINKER_VERSION_FILE} || echo unknown
.else
WANT_LINKER_FREEBSD_VERSION_FILE=
WANT_LINKER_FREEBSD_VERSION=
.endif
.export WANT_LINKER_FREEBSD_VERSION WANT_LINKER_VERSION
.endif # !defined(WANT_LINKER_FREEBSD_VERSION)
.if ${MK_SYSTEM_LINKER} == "yes" && \
defined(WANT_LINKER_FREEBSD_VERSION) && \
(${MK_LLD_BOOTSTRAP} == "yes") && \
!make(xdev*) && \
${X_LINKER_TYPE} == ${WANT_LINKER_TYPE} && \
${X_LINKER_VERSION} == ${WANT_LINKER_VERSION} && \
${X_LINKER_FREEBSD_VERSION} == ${WANT_LINKER_FREEBSD_VERSION}
# Everything matches, disable the bootstrap linker.
MK_LLD_BOOTSTRAP= no
USING_SYSTEM_LINKER= yes
.endif # ${WANT_LINKER_TYPE} == ${LINKER_TYPE}
# WITH_SYSTEM_COMPILER / WITH_SYSTEM_LINKER - Handle defaults and debug.
USING_SYSTEM_COMPILER?= no
USING_SYSTEM_LINKER?= no
TEST_SYSTEM_COMPILER_VARS= \
USING_SYSTEM_COMPILER MK_SYSTEM_COMPILER \
MK_CROSS_COMPILER MK_CLANG_BOOTSTRAP \
WANT_COMPILER_TYPE WANT_COMPILER_VERSION WANT_COMPILER_VERSION_FILE \
WANT_COMPILER_FREEBSD_VERSION WANT_COMPILER_FREEBSD_VERSION_FILE \
CC COMPILER_TYPE COMPILER_FEATURES COMPILER_VERSION \
COMPILER_FREEBSD_VERSION \
XCC X_COMPILER_TYPE X_COMPILER_FEATURES X_COMPILER_VERSION \
X_COMPILER_FREEBSD_VERSION
TEST_SYSTEM_LINKER_VARS= \
USING_SYSTEM_LINKER MK_SYSTEM_LINKER \
MK_LLD_BOOTSTRAP \
WANT_LINKER_TYPE WANT_LINKER_VERSION WANT_LINKER_VERSION_FILE \
WANT_LINKER_FREEBSD_VERSION WANT_LINKER_FREEBSD_VERSION_FILE \
LD LINKER_TYPE LINKER_FEATURES LINKER_VERSION \
LINKER_FREEBSD_VERSION \
XLD X_LINKER_TYPE X_LINKER_FEATURES X_LINKER_VERSION \
X_LINKER_FREEBSD_VERSION
.for _t in compiler linker
test-system-${_t}: .PHONY
.for v in ${TEST_SYSTEM_${_t:tu}_VARS}
${_+_}@printf "%-35s= %s\n" "${v}" "${${v}}"
.endfor
.endfor
.if (make(buildworld) || make(buildkernel) || make(kernel-toolchain) || \
make(toolchain) || make(_cross-tools))
.if ${USING_SYSTEM_COMPILER} == "yes"
.info SYSTEM_COMPILER: Determined that CC=${CC} matches the source tree. Not bootstrapping a cross-compiler.
.elif ${MK_CLANG_BOOTSTRAP} == "yes"
.info SYSTEM_COMPILER: libclang will be built for bootstrapping a cross-compiler.
.endif
.if ${USING_SYSTEM_LINKER} == "yes"
.info SYSTEM_LINKER: Determined that LD=${LD} matches the source tree. Not bootstrapping a cross-linker.
.elif ${MK_LLD_BOOTSTRAP} == "yes"
.info SYSTEM_LINKER: libclang will be built for bootstrapping a cross-linker.
.endif
.endif
# End WITH_SYSTEM_COMPILER / WITH_SYSTEM_LD
# Store some compiler metadata for use in installworld where we don't
# want to invoke CC at all.
_TOOLCHAIN_METADATA_VARS= COMPILER_VERSION \
COMPILER_TYPE \
COMPILER_FEATURES \
COMPILER_FREEBSD_VERSION \
COMPILER_RESOURCE_DIR \
LINKER_VERSION \
LINKER_FEATURES \
LINKER_TYPE \
LINKER_FREEBSD_VERSION
toolchain-metadata.mk: .PHONY .META
@: > ${.TARGET}
@echo ".info Using cached toolchain metadata from build at $$(hostname) on $$(date)" \
> ${.TARGET}
@echo "_LOADED_TOOLCHAIN_METADATA=t" >> ${.TARGET}
.for v in ${_TOOLCHAIN_METADATA_VARS}
@echo "${v}=${${v}}" >> ${.TARGET}
@echo "X_${v}=${X_${v}}" >> ${.TARGET}
.endfor
@echo ".export ${_TOOLCHAIN_METADATA_VARS}" >> ${.TARGET}
@echo ".export ${_TOOLCHAIN_METADATA_VARS:C,^,X_,}" >> ${.TARGET}
# We must do lib/ and libexec/ before bin/ in case of a mid-install error to
# keep the users system reasonably usable. For static->dynamic root upgrades,
# we don't want to install a dynamic binary without rtld and the needed
# libraries. More commonly, for dynamic root, we don't want to install a
# binary that requires a newer library version that hasn't been installed yet.
# This ordering is not a guarantee though. The only guarantee of a working
# system here would require fine-grained ordering of all components based
# on their dependencies.
.if !empty(SUBDIR_OVERRIDE)
SUBDIR= ${SUBDIR_OVERRIDE}
.else
SUBDIR= lib libexec
# Add LOCAL_LIB_DIRS, but only if they will not be picked up as a SUBDIR
# of a LOCAL_DIRS directory. This allows LOCAL_DIRS=foo and
# LOCAL_LIB_DIRS=foo/lib to behave as expected.
.for _DIR in ${LOCAL_DIRS:M*/} ${LOCAL_DIRS:N*/:S|$|/|}
_REDUNDANT_LIB_DIRS+= ${LOCAL_LIB_DIRS:M${_DIR}*}
.endfor
.for _DIR in ${LOCAL_LIB_DIRS}
.if ${_DIR} == ".WAIT" || (empty(_REDUNDANT_LIB_DIRS:M${_DIR}) && exists(${.CURDIR}/${_DIR}/Makefile))
SUBDIR+= ${_DIR}
.endif
.endfor
.if !defined(NO_ROOT) && (make(installworld) || make(install))
# Ensure libraries are installed before progressing.
SUBDIR+=.WAIT
.endif
SUBDIR+=bin
.if ${MK_CDDL} != "no"
SUBDIR+=cddl
.endif
SUBDIR+=gnu include
.if ${MK_KERBEROS} != "no"
SUBDIR+=kerberos5
.endif
.if ${MK_RESCUE} != "no"
SUBDIR+=rescue
.endif
SUBDIR+=sbin
.if ${MK_CRYPT} != "no"
SUBDIR+=secure
.endif
.if !defined(NO_SHARE)
SUBDIR+=share
.endif
.if ${MK_BOOT} != "no"
SUBDIR+=stand
.endif
SUBDIR+=sys usr.bin usr.sbin
.if ${MK_TESTS} != "no"
SUBDIR+= tests
.endif
# Local directories are built in parallel with the base system directories.
# Users may insert a .WAIT directive at the beginning or elsewhere within
# the LOCAL_DIRS and LOCAL_LIB_DIRS lists as needed.
.for _DIR in ${LOCAL_DIRS}
.if ${_DIR} == ".WAIT" || exists(${.CURDIR}/${_DIR}/Makefile)
SUBDIR+= ${_DIR}
.endif
.endfor
# We must do etc/ last as it hooks into building the man whatis file
# by calling 'makedb' in share/man. This is only relevant for
# install/distribute so they build the whatis file after every manpage is
# installed.
.if make(installworld) || make(install)
SUBDIR+=.WAIT
.endif
SUBDIR+=etc
.endif # !empty(SUBDIR_OVERRIDE)
.if defined(NOCLEAN)
.warning The src.conf WITHOUT_CLEAN option can now be used instead of NOCLEAN.
MK_CLEAN:= no
.endif
.if defined(NO_CLEAN)
.info The src.conf WITHOUT_CLEAN option can now be used instead of NO_CLEAN.
MK_CLEAN:= no
.endif
.if defined(NO_CLEANDIR)
CLEANDIR= clean cleandepend
.else
CLEANDIR= cleandir
.endif
.if defined(WORLDFAST)
MK_CLEAN:= no
NO_OBJWALK= t
.endif
.if ${MK_META_MODE} == "yes"
# If filemon is used then we can rely on the build being incremental-safe.
# The .meta files will also track the build command and rebuild should
# it change.
.if empty(.MAKE.MODE:Mnofilemon)
MK_CLEAN:= no
.endif
.endif
.if defined(NO_OBJWALK) || ${MK_AUTO_OBJ} == "yes"
NO_OBJWALK= t
NO_KERNELOBJ= t
.endif
.if !defined(NO_OBJWALK)
_obj= obj
.endif
LOCAL_TOOL_DIRS?=
PACKAGEDIR?= ${DESTDIR}/${DISTDIR}
.if empty(SHELL:M*csh*)
BUILDENV_SHELL?=${SHELL}
.else
BUILDENV_SHELL?=/bin/sh
.endif
.if !defined(_MKSHOWCONFIG)
.if !defined(VCS_REVISION) || empty(VCS_REVISION)
.if !defined(SVNVERSION_CMD) || empty(SVNVERSION_CMD)
. for _D in ${PATH:S,:, ,g}
. if exists(${_D}/svnversion)
SVNVERSION_CMD?=${_D}/svnversion
. endif
. if exists(${_D}/svnliteversion)
SVNVERSION_CMD?=${_D}/svnliteversion
. endif
. endfor
.endif
.if defined(SVNVERSION_CMD) && !empty(SVNVERSION_CMD)
_VCS_REVISION?= $$(eval ${SVNVERSION_CMD} ${SRCDIR})
. if !empty(_VCS_REVISION)
VCS_REVISION= $$(echo r${_VCS_REVISION})
.export VCS_REVISION
. endif
.endif
.endif
.if !defined(GIT_CMD) || empty(GIT_CMD)
. for _P in /usr/bin /usr/local/bin
. if exists(${_P}/git)
GIT_CMD= ${_P}/git
. endif
. endfor
.export GIT_CMD
.endif
.if !defined(OSRELDATE)
.if exists(/usr/include/osreldate.h)
OSRELDATE!= awk '/^\#define[[:space:]]*__FreeBSD_version/ { print $$3 }' \
/usr/include/osreldate.h
.else
OSRELDATE= 0
.endif
.export OSRELDATE
.endif
# Set VERSION for CTFMERGE to use via the default CTFFLAGS=-L VERSION.
.for _V in BRANCH REVISION TYPE
.if !defined(_${_V})
_${_V}!= eval $$(awk '/^${_V}=/{print}' ${SRCTOP}/sys/conf/newvers.sh); echo $$${_V}
.export _${_V}
.endif
.endfor
.if !defined(SRCRELDATE)
SRCRELDATE!= awk '/^\#define[[:space:]]*__FreeBSD_version/ { print $$3 }' \
${SRCDIR}/sys/sys/param.h
.export SRCRELDATE
.endif
.if !defined(VERSION)
VERSION= FreeBSD ${_REVISION}-${_BRANCH:C/-p[0-9]+$//} ${TARGET_ARCH} ${SRCRELDATE}
.export VERSION
.endif
.if !defined(PKG_VERSION)
_STRTIMENOW= %Y%m%d%H%M%S
_TIMENOW= ${_STRTIMENOW:gmtime}
.if ${_BRANCH:MCURRENT*} || ${_BRANCH:MSTABLE*} || ${_BRANCH:MPRERELEASE*}
_REVISION:= ${_REVISION:R}
EXTRA_REVISION= .snap${_TIMENOW}
.elif ${_BRANCH:MALPHA*}
EXTRA_REVISION= .a${_BRANCH:C/ALPHA([0-9]+).*/\1/}.${_TIMENOW}
.elif ${_BRANCH:MBETA*}
EXTRA_REVISION= .b${_BRANCH:C/BETA([0-9]+).*/\1/}.${_TIMENOW}
.elif ${_BRANCH:MRC*}
EXTRA_REVISION= .rc${_BRANCH:C/RC([0-9]+).*/\1/}.${_TIMENOW}
.elif ${_BRANCH:M*-p*}
EXTRA_REVISION= p${_BRANCH:C/.*-p([0-9]+$)/\1/}
.endif
PKG_VERSION:= ${_REVISION}${EXTRA_REVISION:C/[[:space:]]//g}
.endif
.endif # !defined(PKG_VERSION)
.if !defined(PKG_TIMESTAMP)
TIMEEPOCHNOW= %s
SOURCE_DATE_EPOCH= ${TIMEEPOCHNOW:gmtime}
.else
SOURCE_DATE_EPOCH= ${PKG_TIMESTAMP}
.endif
PKG_NAME_PREFIX?= FreeBSD
PKG_MAINTAINER?= re@FreeBSD.org
PKG_WWW?= https://www.FreeBSD.org
.export PKG_NAME_PREFIX
.export PKG_MAINTAINER
.export PKG_WWW
.if !defined(_MKSHOWCONFIG)
_CPUTYPE!= MAKEFLAGS= CPUTYPE=${_TARGET_CPUTYPE} ${MAKE} -f /dev/null \
-m ${.CURDIR}/share/mk MK_AUTO_OBJ=no -V CPUTYPE
.if ${_CPUTYPE} != ${_TARGET_CPUTYPE}
.error CPUTYPE global should be set with ?=.
.endif
.endif
.if make(buildworld)
BUILD_ARCH!= uname -p
# On some Linux systems uname -p returns "unknown" so skip this check there.
# This check only exists to tell people to use TARGET_ARCH instead of
# MACHINE_ARCH so skipping it when crossbuilding on non-FreeBSD should be fine.
.if ${MACHINE_ARCH} != ${BUILD_ARCH} && ${.MAKE.OS} == "FreeBSD"
.error To cross-build, set TARGET_ARCH.
.endif
.endif
WORLDTMP?= ${OBJTOP}/tmp
BPATH= ${CCACHE_WRAPPER_PATH_PFX}${WORLDTMP}/legacy/usr/sbin:${WORLDTMP}/legacy/usr/bin:${WORLDTMP}/legacy/bin:${WORLDTMP}/legacy/usr/libexec
XPATH= ${WORLDTMP}/bin:${WORLDTMP}/usr/sbin:${WORLDTMP}/usr/bin
# When building we want to find the cross tools before the host tools in ${BPATH}.
# We also need to add UNIVERSE_TOOLCHAIN_PATH so that we can find the shared
# toolchain files (clang, lld, etc.) during make universe/tinderbox
STRICTTMPPATH= ${XPATH}:${BPATH}:${UNIVERSE_TOOLCHAIN_PATH}
# We should not be using tools from /usr/bin accidentally since this could cause
# the build to break on other systems that don't have that tool. For now we
# still allow using the old behaviour (inheriting $PATH) if
# BUILD_WITH_STRICT_TMPPATH is set to 0 but this will eventually be removed.
# Currently strict $PATH can cause build failures and does not work yet with
# USING_SYSTEM_LINKER/USING_SYSTEM_COMPILER. Once these issues have been
# resolved it will be turned on by default.
BUILD_WITH_STRICT_TMPPATH?=0
.if defined(CROSSBUILD_HOST)
# When building on non-FreeBSD we can't rely on the tools in /usr/bin being compatible
# with what FreeBSD expects. Therefore we only use tools from STRICTTMPPATH
# during the world build stage. We build most tools during the bootstrap-tools
# phase but symlink host tools that are known to work instead of building them
BUILD_WITH_STRICT_TMPPATH:=1
.endif
.if ${BUILD_WITH_STRICT_TMPPATH} != 0
TMPPATH= ${STRICTTMPPATH}
.else
TMPPATH= ${STRICTTMPPATH}:${PATH}
.endif
#
# Avoid running mktemp(1) unless actually needed.
# It may not be functional, e.g., due to new ABI
# when in the middle of installing over this system.
#
.if make(distributeworld) || make(installworld) || make(stageworld)
.if ${BUILD_WITH_STRICT_TMPPATH} != 0
MKTEMP=${WORLDTMP}/legacy/usr/bin/mktemp
.if !exists(${MKTEMP})
.error mktemp binary doesn't exist in expected location: ${MKTEMP}
.endif
.else
MKTEMP=mktemp
.endif
INSTALLTMP!= ${MKTEMP} -d -u -t install
.endif
.if make(stagekernel) || make(distributekernel)
TAGS+= kernel
PACKAGE= kernel
.endif
#
# Building a world goes through the following stages
#
# 1. legacy stage [BMAKE]
# This stage is responsible for creating compatibility
# shims that are needed by the bootstrap-tools,
# build-tools and cross-tools stages. These are generally
# APIs that tools from one of those three stages need to
# build that aren't present on the host.
# 1. bootstrap-tools stage [BMAKE]
# This stage is responsible for creating programs that
# are needed for backward compatibility reasons. They
# are not built as cross-tools.
# 2. build-tools stage [TMAKE]
# This stage is responsible for creating the object
# tree and building any tools that are needed during
# the build process. Some programs are listed during
# this phase because they build binaries to generate
# files needed to build these programs. This stage also
# builds the 'build-tools' target rather than 'all'.
# 3. cross-tools stage [XMAKE]
# This stage is responsible for creating any tools that
# are needed for building the system. A cross-compiler is one
# of them. This differs from build tools in two ways:
# 1. the 'all' target is built rather than 'build-tools'
# 2. these tools are installed into TMPPATH for stage 4.
# 4. world stage [WMAKE]
# This stage actually builds the world.
# 5. install stage (optional) [IMAKE]
# This stage installs a previously built world.
#
BOOTSTRAPPING?= 0
# Keep these in sync
MINIMUM_SUPPORTED_OSREL?= 1104001
MINIMUM_SUPPORTED_REL?= 11.4
# Common environment for world related stages
CROSSENV+= \
MACHINE_ARCH=${TARGET_ARCH} \
MACHINE=${TARGET} \
CPUTYPE=${TARGET_CPUTYPE}
.if ${MK_META_MODE} != "no"
# Don't rebuild build-tools targets during normal build.
CROSSENV+= BUILD_TOOLS_META=.NOMETA
.endif
.if defined(TARGET_CFLAGS)
CROSSENV+= ${TARGET_CFLAGS}
.endif
.if (${TARGET} != ${MACHINE} && !defined(WITH_LOCAL_MODULES)) || \
defined(WITHOUT_LOCAL_MODULES)
CROSSENV+= LOCAL_MODULES=
.endif
BOOTSTRAPPING_OSRELDATE?=${OSRELDATE}
# bootstrap-tools stage
BMAKEENV= INSTALL="sh ${.CURDIR}/tools/install.sh" \
TOOLS_PREFIX=${TOOLS_PREFIX_UNDEF:U${WORLDTMP}} \
PATH=${BPATH}:${PATH} \
WORLDTMP=${WORLDTMP} \
MAKEFLAGS="-m ${.CURDIR}/tools/build/mk ${.MAKEFLAGS}"
# need to keep this in sync with targets/pseudo/bootstrap-tools/Makefile
BSARGS= DESTDIR= \
OBJTOP='${WORLDTMP}/obj-tools' \
OBJROOT='$${OBJTOP}/' \
MAKEOBJDIRPREFIX= \
BOOTSTRAPPING=${BOOTSTRAPPING_OSRELDATE} \
BWPHASE=${.TARGET:C,^_,,} \
-DNO_CPU_CFLAGS \
-DNO_LINT \
-DNO_PIC \
-DNO_SHARED \
MK_ASAN=no \
MK_CTF=no \
MK_CLANG_EXTRAS=no \
MK_CLANG_FORMAT=no \
MK_CLANG_FULL=no \
MK_HTML=no \
MK_MAN=no \
MK_PROFILE=no \
MK_RETPOLINE=no \
MK_SSP=no \
MK_TESTS=no \
MK_UBSAN=no \
MK_WERROR=no \
MK_INCLUDES=yes \
MK_MAN_UTILS=yes
BMAKE= \
${TIME_ENV} ${BMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \
${BSARGS}
.if empty(.MAKEOVERRIDES:MMK_LLVM_TARGET_ALL)
BMAKE+= MK_LLVM_TARGET_ALL=no
.endif
# build-tools stage
TMAKE= \
${TIME_ENV} ${BMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \
TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} \
DESTDIR= \
BOOTSTRAPPING=${BOOTSTRAPPING_OSRELDATE} \
BWPHASE=${.TARGET:C,^_,,} \
-DNO_CPU_CFLAGS \
-DNO_LINT \
MK_ASAN=no \
MK_CTF=no \
MK_CLANG_EXTRAS=no \
MK_CLANG_FORMAT=no \
MK_CLANG_FULL=no \
MK_LLDB=no \
MK_RETPOLINE=no \
MK_SSP=no \
MK_TESTS=no \
MK_UBSAN=no \
MK_WERROR=no
# cross-tools stage
# TOOLS_PREFIX set in BMAKE
XMAKE= ${BMAKE} \
TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} \
MK_CLANG_IS_CC=${MK_CLANG_BOOTSTRAP} \
MK_LLDB=no \
MK_LLVM_BINUTILS=no \
MK_TESTS=no
# kernel-tools stage
KTMAKEENV= INSTALL="sh ${.CURDIR}/tools/install.sh" \
PATH=${BPATH}:${PATH} \
WORLDTMP=${WORLDTMP} \
MAKEFLAGS="-m ${.CURDIR}/tools/build/mk ${.MAKEFLAGS}"
KTMAKE= ${TIME_ENV} \
TOOLS_PREFIX=${TOOLS_PREFIX_UNDEF:U${WORLDTMP}} \
${KTMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \
DESTDIR= \
OBJTOP='${WORLDTMP}/obj-kernel-tools' \
OBJROOT='$${OBJTOP}/' \
MAKEOBJDIRPREFIX= \
BOOTSTRAPPING=${BOOTSTRAPPING_OSRELDATE} \
-DNO_CPU_CFLAGS \
-DNO_LINT \
-DNO_PIC \
-DNO_SHARED \
MK_CTF=no \
MK_HTML=no \
MK_MAN=no \
MK_PROFILE=no \
MK_SSP=no \
MK_RETPOLINE=no \
MK_WERROR=no
# world stage
WMAKEENV= ${CROSSENV} \
INSTALL="${INSTALL_CMD} -U" \
PATH=${TMPPATH} \
SYSROOT=${WORLDTMP}
# make hierarchy
HMAKE= PATH=${TMPPATH} ${MAKE} LOCAL_MTREE=${LOCAL_MTREE:Q}
.if defined(NO_ROOT)
HMAKE+= PATH=${TMPPATH} METALOG=${METALOG} -DNO_ROOT
.endif
CROSSENV+= CC="${XCC} ${XCFLAGS}" CXX="${XCXX} ${XCXXFLAGS} ${XCFLAGS}" \
CPP="${XCPP} ${XCFLAGS}" \
AS="${XAS}" AR="${XAR}" ELFCTL="${XELFCTL}" LD="${XLD}" \
LLVM_LINK="${XLLVM_LINK}" NM=${XNM} OBJCOPY="${XOBJCOPY}" \
RANLIB=${XRANLIB} STRINGS=${XSTRINGS} \
SIZE="${XSIZE}" STRIPBIN="${XSTRIPBIN}"
.if defined(CROSS_BINUTILS_PREFIX) && exists(${CROSS_BINUTILS_PREFIX})
# In the case of xdev-build tools, CROSS_BINUTILS_PREFIX won't be a
# directory, but the compiler will look in the right place for its
# tools so we don't need to tell it where to look.
BFLAGS+= -B${CROSS_BINUTILS_PREFIX}
.endif
# The internal bootstrap compiler has a default sysroot set by TOOLS_PREFIX
# and target set by TARGET/TARGET_ARCH. However, there are several needs to
# always pass an explicit --sysroot and -target.
# - External compiler needs sysroot and target flags.
# - External ld needs sysroot.
# - To be clear about the use of a sysroot when using the internal compiler.
# - Easier debugging.
# - Allowing WITH_SYSTEM_COMPILER+WITH_META_MODE to work together due to
# the flip-flopping build command when sometimes using external and
# sometimes using internal.
# - Allow using lld which has no support for default paths.
.if !defined(CROSS_BINUTILS_PREFIX) || !exists(${CROSS_BINUTILS_PREFIX})
BFLAGS+= -B${WORLDTMP}/usr/bin
.endif
.if ${WANT_COMPILER_TYPE} == gcc || \
(defined(X_COMPILER_TYPE) && ${X_COMPILER_TYPE} == gcc)
.elif ${WANT_COMPILER_TYPE} == clang || \
(defined(X_COMPILER_TYPE) && ${X_COMPILER_TYPE} == clang)
XCFLAGS+= -target ${TARGET_TRIPLE}
.endif
XCFLAGS+= --sysroot=${WORLDTMP}
.if !empty(BFLAGS)
XCFLAGS+= ${BFLAGS}
.endif
.if ${MK_LIB32} == "yes"
_LIBCOMPAT= 32
.include "Makefile.libcompat"
.endif
# META_MODE normally ignores host file changes since every build updates
# timestamps (see NO_META_IGNORE_HOST in sys.mk). There are known times
# when the ABI breaks though that we want to force rebuilding WORLDTMP
# to get updated host tools.
.if ${MK_META_MODE} == "yes" && ${MK_CLEAN} == "no" && \
!defined(NO_META_IGNORE_HOST) && !defined(NO_META_IGNORE_HOST_HEADERS) && \
!defined(_MKSHOWCONFIG)
# r318736 - ino64 major ABI breakage
META_MODE_BAD_ABI_VERS+= 1200031
.if !defined(OBJDIR_HOST_OSRELDATE)
.if exists(${OBJTOP}/host-osreldate.h)
OBJDIR_HOST_OSRELDATE!= \
awk '/^\#define[[:space:]]*__FreeBSD_version/ { print $$3 }' \
${OBJTOP}/host-osreldate.h
.elif exists(${WORLDTMP}/usr/include/osreldate.h)
OBJDIR_HOST_OSRELDATE= 0
.endif
.export OBJDIR_HOST_OSRELDATE
.endif
# Note that this logic is the opposite of normal BOOTSTRAP handling. We want
# to compare the WORLDTMP's OSRELDATE to the host's OSRELDATE. If the WORLDTMP
# is older than the ABI-breakage OSRELDATE of the HOST then we rebuild.
.if defined(OBJDIR_HOST_OSRELDATE)
.for _ver in ${META_MODE_BAD_ABI_VERS}
.if ${OSRELDATE} >= ${_ver} && ${OBJDIR_HOST_OSRELDATE} < ${_ver}
_meta_mode_need_rebuild= ${_ver}
.endif
.endfor
.if defined(_meta_mode_need_rebuild)
.info META_MODE: Rebuilding host tools due to ABI breakage in __FreeBSD_version ${_meta_mode_need_rebuild}.
NO_META_IGNORE_HOST_HEADERS= 1
.export NO_META_IGNORE_HOST_HEADERS
.endif # defined(_meta_mode_need_rebuild)
.endif # defined(OBJDIR_HOST_OSRELDATE)
.endif # ${MK_META_MODE} == "yes" && ${MK_CLEAN} == "no" ...
# This is only used for META_MODE+filemon to track what the oldest
# __FreeBSD_version is in WORLDTMP. This purposely does NOT have
# a make dependency on /usr/include/osreldate.h as the file should
# only be copied when it is missing or meta mode determines it has changed.
# Since host files are normally ignored without NO_META_IGNORE_HOST
# the file will never be updated unless that flag is specified. This
# allows tracking the oldest osreldate to force rebuilds via
# META_MODE_BADABI_REVS above.
host-osreldate.h: # DO NOT ADD /usr/include/osreldate.h here
.if !defined(CROSSBUILD_HOST)
@cp -f /usr/include/osreldate.h ${.TARGET}
.else
@echo "#ifndef __FreeBSD_version" > ${.TARGET}
@echo "#define __FreeBSD_version ${OSRELDATE}" >> ${.TARGET}
@echo "#endif" >> ${.TARGET}
.endif
WMAKE= ${TIME_ENV} ${WMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \
BWPHASE=${.TARGET:C,^_,,} \
DESTDIR=${WORLDTMP}
IMAKEENV= ${CROSSENV}
IMAKE= ${TIME_ENV} ${IMAKEENV} ${MAKE} -f Makefile.inc1 \
${IMAKE_INSTALL} ${IMAKE_MTREE}
.if empty(.MAKEFLAGS:M-n)
IMAKEENV+= PATH=${STRICTTMPPATH}:${INSTALLTMP} \
LD_LIBRARY_PATH=${INSTALLTMP} \
PATH_LOCALE=${INSTALLTMP}/locale
IMAKE+= __MAKE_SHELL=${INSTALLTMP}/sh
.else
IMAKEENV+= PATH=${TMPPATH}:${INSTALLTMP}
.endif
# When generating install media, do not allow user and group information from
# the build host to affect the contents of the distribution.
.if make(distributeworld) || make(distrib-dirs) || make(distribution) || \
make(stageworld)
DB_FROM_SRC= yes
.endif
.if defined(DB_FROM_SRC)
INSTALLFLAGS+= -N ${.CURDIR}/etc
MTREEFLAGS+= -N ${.CURDIR}/etc
.endif
_INSTALL_DDIR= ${DESTDIR}/${DISTDIR}
INSTALL_DDIR= ${_INSTALL_DDIR:S://:/:g:C:/$::}
.if defined(NO_ROOT)
METALOG?= ${DESTDIR}/${DISTDIR}/METALOG
METALOG:= ${METALOG:C,//+,/,g}
IMAKE+= -DNO_ROOT METALOG=${METALOG}
METALOG_INSTALLFLAGS= -U -M ${METALOG} -D ${INSTALL_DDIR}
INSTALLFLAGS+= ${METALOG_INSTALLFLAGS}
CERTCTLFLAGS= ${METALOG_INSTALLFLAGS}
MTREEFLAGS+= -W
.endif
.if defined(BUILD_PKGS)
INSTALLFLAGS+= -h sha256
.endif
.if defined(DB_FROM_SRC) || defined(NO_ROOT)
IMAKE_INSTALL= INSTALL="${INSTALL_CMD} ${INSTALLFLAGS}"
IMAKE_MTREE= MTREE_CMD="${MTREE_CMD} ${MTREEFLAGS}"
.endif
.if make(distributeworld)
CERTCTLDESTDIR= ${DESTDIR}/${DISTDIR}/base
.else
CERTCTLDESTDIR= ${DESTDIR}
.endif
DESTDIR_MTREEFLAGS= -deU
# When creating worldtmp we don't need to set the directories as owned by root
# so we also pass -W
WORLDTMP_MTREEFLAGS= -deUW
.if defined(NO_ROOT)
# When building with -DNO_ROOT we shouldn't be changing the directories
# that are created by mtree to be owned by root/wheel.
DESTDIR_MTREEFLAGS+= -W
.endif
DISTR_MTREE= ${MTREE_CMD}
.if ${BUILD_WITH_STRICT_TMPPATH} != 0
DISTR_MTREE= ${WORLDTMP}/legacy/usr/sbin/mtree
.endif
WORLDTMP_MTREE= ${DISTR_MTREE} ${WORLDTMP_MTREEFLAGS}
DESTDIR_MTREE= ${DISTR_MTREE} ${DESTDIR_MTREEFLAGS}
# kernel stage
KMAKEENV= ${WMAKEENV:NSYSROOT=*}
KMAKE= ${TIME_ENV} ${KMAKEENV} ${MAKE} ${.MAKEFLAGS} ${KERNEL_FLAGS} KERNEL=${INSTKERNNAME}
#
# buildworld
#
# Attempt to rebuild the entire system, with reasonable chance of
# success, regardless of how old your existing system is.
#
_sanity_check: .PHONY .MAKE
.if ${.CURDIR:C/[^,]//g} != ""
# The m4 build of sendmail files doesn't like it if ',' is used
# anywhere in the path of it's files.
@echo
@echo "*** Error: path to source tree contains a comma ','"
@echo
@false
.elif ${.CURDIR:M*\:*} != ""
# Using ':' leaks into PATH and breaks finding cross-tools.
@echo
@echo "*** Error: path to source tree contains a colon ':'"
@echo
@false
.endif
# Our current approach to dependency tracking cannot cope with certain source
# tree changes, particularly with respect to removing source files and
# replacing generated files. Handle these cases here in an ad-hoc fashion.
_cleanobj_fast_depend_hack: .PHONY
@echo ">>> Deleting stale dependencies...";
sh ${.CURDIR}/tools/build/depend-cleanup.sh ${OBJTOP}
_worldtmp: .PHONY
@echo
@echo "--------------------------------------------------------------"
@echo ">>> Rebuilding the temporary build tree"
@echo "--------------------------------------------------------------"
.if ${MK_CLEAN} == "yes"
rm -rf ${WORLDTMP}
.else
# Note: for delete-old we need to set $PATH to also include the host $PATH
# since otherwise a partial build with missing symlinks in ${WORLDTMP}/legacy/
# will fail to run due to missing binaries. $WMAKE sets PATH to only ${TMPPATH}
# so we remove that assingnment from $WMAKE and prepend the new $PATH
${_+_}@if [ -e "${WORLDTMP}" ]; then \
echo ">>> Deleting stale files in build tree..."; \
cd ${.CURDIR}; env PATH=${TMPPATH}:${PATH} ${WMAKE:NPATH=*} \
_NO_INCLUDE_COMPILERMK=t -DBATCH_DELETE_OLD_FILES delete-old \
delete-old-libs >/dev/null; \
fi
rm -rf ${WORLDTMP}/legacy/usr/include
.if ${USING_SYSTEM_COMPILER} == "yes"
.for cc in cc c++
if [ -x ${WORLDTMP}/usr/bin/${cc} ]; then \
inum=$$(stat -f %i ${WORLDTMP}/usr/bin/${cc}); \
find ${WORLDTMP}/usr/bin -inum $${inum} -delete; \
fi
.endfor
.endif # ${USING_SYSTEM_COMPILER} == "yes"
.if ${USING_SYSTEM_LINKER} == "yes"
@rm -f ${WORLDTMP}/usr/bin/ld ${WORLDTMP}/usr/bin/ld.lld
.endif # ${USING_SYSTEM_LINKER} == "yes"
.endif # ${MK_CLEAN} == "yes"
@mkdir -p ${WORLDTMP}
@touch ${WORLDTMP}/${.TARGET}
# We can't use mtree to create the worldtmp directories since it may not be
# available on the target system (this happens e.g. when building on non-FreeBSD)
${_+_}cd ${.CURDIR}/tools/build; \
${MAKE} DIRPRFX=tools/build/ DESTDIR=${WORLDTMP}/legacy installdirs
# In order to build without inheriting $PATH we need to add symlinks to the host
# tools in $WORLDTMP for the tools that we don't build during bootstrap-tools
${_+_}cd ${.CURDIR}/tools/build; \
${MAKE} DIRPRFX=tools/build/ DESTDIR=${WORLDTMP}/legacy host-symlinks
_legacy:
@echo
@echo "--------------------------------------------------------------"
@echo ">>> stage 1.1: legacy release compatibility shims"
@echo "--------------------------------------------------------------"
${_+_}cd ${.CURDIR}; ${BMAKE} legacy
_bootstrap-tools:
@echo
@echo "--------------------------------------------------------------"
@echo ">>> stage 1.2: bootstrap tools"
@echo "--------------------------------------------------------------"
${_+_}cd ${.CURDIR}; ${BMAKE} bootstrap-tools
mkdir -p ${WORLDTMP}/usr ${WORLDTMP}/lib/casper ${WORLDTMP}/lib/geom \
${WORLDTMP}/bin
${WORLDTMP_MTREE} -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
-p ${WORLDTMP}/usr >/dev/null
${WORLDTMP_MTREE} -f ${.CURDIR}/etc/mtree/BSD.include.dist \
-p ${WORLDTMP}/usr/include >/dev/null
ln -sf ${.CURDIR}/sys ${WORLDTMP}
.if ${MK_DEBUG_FILES} != "no"
${WORLDTMP_MTREE} -f ${.CURDIR}/etc/mtree/BSD.debug.dist \
-p ${WORLDTMP}/usr/lib >/dev/null
.endif
.for _mtree in ${LOCAL_MTREE}
${WORLDTMP_MTREE} -f ${.CURDIR}/${_mtree} -p ${WORLDTMP} > /dev/null
.endfor
_cleanobj:
.if ${MK_CLEAN} == "yes"
@echo
@echo "--------------------------------------------------------------"
@echo ">>> stage 2.1: cleaning up the object tree"
@echo "--------------------------------------------------------------"
# Avoid including bsd.compiler.mk in clean and obj with _NO_INCLUDE_COMPILERMK
# since the restricted $PATH might not contain a valid cc binary
${_+_}cd ${.CURDIR}; ${WMAKE} _NO_INCLUDE_COMPILERMK=t ${CLEANDIR}
.if defined(_LIBCOMPAT)
${_+_}cd ${.CURDIR}; ${LIBCOMPATWMAKE} _NO_INCLUDE_COMPILERMK=t -f Makefile.inc1 ${CLEANDIR}
.endif
.else
${_+_}cd ${.CURDIR}; ${WMAKE} _NO_INCLUDE_COMPILERMK=t _cleanobj_fast_depend_hack
.endif # ${MK_CLEAN} == "yes"
_obj:
@echo
@echo "--------------------------------------------------------------"
@echo ">>> stage 2.2: rebuilding the object tree"
@echo "--------------------------------------------------------------"
${_+_}cd ${.CURDIR}; ${WMAKE} _NO_INCLUDE_COMPILERMK=t obj
_build-tools:
@echo
@echo "--------------------------------------------------------------"
@echo ">>> stage 2.3: build tools"
@echo "--------------------------------------------------------------"
${_+_}cd ${.CURDIR}; ${TMAKE} build-tools
_cross-tools:
@echo
@echo "--------------------------------------------------------------"
@echo ">>> stage 3: cross tools"
@echo "--------------------------------------------------------------"
@rm -f ${OBJTOP}/toolchain-metadata.mk
${_+_}cd ${.CURDIR}; ${XMAKE} cross-tools
${_+_}cd ${.CURDIR}; ${XMAKE} kernel-tools
_build-metadata:
@echo
@echo "--------------------------------------------------------------"
@echo ">>> stage 3.1: recording build metadata"
@echo "--------------------------------------------------------------"
${_+_}cd ${.CURDIR}; ${WMAKE} toolchain-metadata.mk
${_+_}cd ${.CURDIR}; ${WMAKE} host-osreldate.h
_includes:
@echo
@echo "--------------------------------------------------------------"
@echo ">>> stage 4.1: building includes"
@echo "--------------------------------------------------------------"
# Special handling for SUBDIR_OVERRIDE in buildworld as they most likely need
# headers from default SUBDIR. Do SUBDIR_OVERRIDE includes last.
${_+_}cd ${.CURDIR}; ${WMAKE} SUBDIR_OVERRIDE= SHARED=symlinks \
MK_INCLUDES=yes includes
.if !empty(SUBDIR_OVERRIDE) && make(buildworld)
${_+_}cd ${.CURDIR}; ${WMAKE} MK_INCLUDES=yes SHARED=symlinks includes
.endif
${_+_}cd ${.CURDIR}; ${WMAKE} test-includes
_libraries:
@echo
@echo "--------------------------------------------------------------"
@echo ">>> stage 4.2: building libraries"
@echo "--------------------------------------------------------------"
${_+_}cd ${.CURDIR}; \
${WMAKE} -DNO_FSCHG MK_HTML=no -DNO_LINT MK_MAN=no \
MK_PROFILE=no MK_TESTS=no MK_TESTS_SUPPORT=${MK_TESTS_SUPPORT} \
libraries
everything: .PHONY
@echo
@echo "--------------------------------------------------------------"
@echo ">>> stage 4.4: building everything"
@echo "--------------------------------------------------------------"
${_+_}cd ${.CURDIR}; _PARALLEL_SUBDIR_OK=1 ${WMAKE} all
WMAKE_TGTS=
.if !defined(WORLDFAST)
WMAKE_TGTS+= _sanity_check _worldtmp _legacy
.if empty(SUBDIR_OVERRIDE)
WMAKE_TGTS+= _bootstrap-tools
.endif
WMAKE_TGTS+= _cleanobj
.if !defined(NO_OBJWALK)
WMAKE_TGTS+= _obj
.endif
WMAKE_TGTS+= _build-tools _cross-tools
WMAKE_TGTS+= _build-metadata
WMAKE_TGTS+= _includes
.endif
.if !defined(NO_LIBS)
WMAKE_TGTS+= _libraries
.endif
.if defined(_LIBCOMPAT) && empty(SUBDIR_OVERRIDE)
WMAKE_TGTS+= build${libcompat}
.endif
WMAKE_TGTS+= everything
# record buildworld time in seconds
.if make(buildworld)
_BUILDWORLD_START!= date '+%s'
.export _BUILDWORLD_START
.endif
buildworld: buildworld_prologue ${WMAKE_TGTS} buildworld_epilogue .PHONY
.ORDER: buildworld_prologue ${WMAKE_TGTS} buildworld_epilogue
_ncpu_cmd=sysctl -n hw.ncpu 2>/dev/null || nproc 2>/dev/null || echo unknown
buildworld_prologue: .PHONY
@echo "--------------------------------------------------------------"
@echo ">>> World build started on `LC_ALL=C date`"
@echo "--------------------------------------------------------------"
buildworld_epilogue: .PHONY
@echo
@echo "--------------------------------------------------------------"
@echo ">>> World build completed on `LC_ALL=C date`"
@seconds=$$(($$(date '+%s') - ${_BUILDWORLD_START})); \
echo -n ">>> World built in $$seconds seconds, "; \
echo "ncpu: $$(${_ncpu_cmd})${.MAKE.JOBS:S/^/, make -j/}"
@echo "--------------------------------------------------------------"
#
# We need to have this as a target because the indirection between Makefile
# and Makefile.inc1 causes the correct PATH to be used, rather than a
# modification of the current environment's PATH. In addition, we need
# to quote multiword values.
#
buildenvvars: .PHONY
@echo ${WMAKEENV:Q} ${.MAKE.EXPORTED:@v@$v=\"${$v}\"@}
.if ${.TARGETS:Mbuildenv}
.if ${.MAKEFLAGS:M-j}
.error The buildenv target is incompatible with -j
.endif
.endif
BUILDENV_DIR?= ${.CURDIR}
#
# Note: make will report any errors the shell reports. This can
# be odd if the last command in an interactive shell generates an
# error or is terminated by SIGINT. These reported errors look bad,
# but are harmless. Allowing them also allows BUILDENV_SHELL to
# be a complex command whose status will be returned to the caller.
# Some scripts in tools rely on this behavior to report build errors.
#
buildenv: .PHONY
@echo Entering world for ${TARGET_ARCH}:${TARGET}
.if ${BUILDENV_SHELL:M*zsh*}
@echo For ZSH you must run: export CPUTYPE=${TARGET_CPUTYPE}
.endif
@cd ${BUILDENV_DIR} && env ${WMAKEENV} \
INSTALL="${INSTALL_CMD} ${INSTALLFLAGS}" \
MTREE_CMD="${MTREE_CMD} ${MTREEFLAGS}" BUILDENV=1 ${BUILDENV_SHELL}
TOOLCHAIN_TGTS= ${WMAKE_TGTS:Neverything:Nbuild${libcompat}}
toolchain: ${TOOLCHAIN_TGTS} .PHONY
KERNEL_TOOLCHAIN_TGTS= ${TOOLCHAIN_TGTS:N_obj:N_cleanobj:N_includes:N_libraries}
.if make(kernel-toolchain)
.ORDER: ${KERNEL_TOOLCHAIN_TGTS}
.endif
kernel-toolchain: ${KERNEL_TOOLCHAIN_TGTS} .PHONY
#
# installcheck
#
# Checks to be sure system is ready for installworld/installkernel.
#
installcheck: _installcheck_world _installcheck_kernel .PHONY
_installcheck_world: .PHONY
@echo "--------------------------------------------------------------"
@echo ">>> Install check world"
@echo "--------------------------------------------------------------"
_installcheck_kernel: .PHONY
@echo "--------------------------------------------------------------"
@echo ">>> Install check kernel"
@echo "--------------------------------------------------------------"
#
# Require DESTDIR to be set if installing for a different architecture or
# using the user/group database in the source tree.
#
.if ${TARGET_ARCH} != ${MACHINE_ARCH} || ${TARGET} != ${MACHINE} || \
defined(DB_FROM_SRC)
.if !make(distributeworld)
_installcheck_world: __installcheck_DESTDIR
_installcheck_kernel: __installcheck_DESTDIR
__installcheck_DESTDIR: .PHONY
.if !defined(DESTDIR) || empty(DESTDIR)
@echo "ERROR: Please set DESTDIR!"; \
false
.endif
.endif
.endif
.if !defined(DB_FROM_SRC)
#
# Check for missing UIDs/GIDs.
#
CHECK_UIDS= auditdistd
CHECK_GIDS= audit
CHECK_UIDS+= ntpd
CHECK_GIDS+= ntpd
CHECK_UIDS+= proxy
CHECK_GIDS+= proxy authpf
CHECK_UIDS+= smmsp
CHECK_GIDS+= smmsp
CHECK_UIDS+= unbound
CHECK_GIDS+= unbound
_installcheck_world: __installcheck_UGID
__installcheck_UGID: .PHONY
.for uid in ${CHECK_UIDS}
@if ! `id -u ${uid} >/dev/null 2>&1`; then \
echo "ERROR: Required ${uid} user is missing, see /usr/src/UPDATING."; \
false; \
fi
.endfor
.for gid in ${CHECK_GIDS}
@if ! `find / -prune -group ${gid} >/dev/null 2>&1`; then \
echo "ERROR: Required ${gid} group is missing, see /usr/src/UPDATING."; \
false; \
fi
.endfor
.endif
#
# If installing over the running system (DESTDIR is / or unset) and the install
# includes rescue, try running rescue from the objdir as a sanity check. If
# rescue is not functional (e.g., because it depends on a system call not
# supported by the currently running kernel), abort the installation.
#
.if !make(distributeworld) && ${MK_RESCUE} != "no" && \
(empty(DESTDIR) || ${DESTDIR} == "/") && empty(BYPASS_INSTALLCHECK_SH)
_installcheck_world: __installcheck_sh_check
__installcheck_sh_check: .PHONY
@if [ "`${OBJTOP}/rescue/rescue/rescue sh -c 'echo OK'`" != \
OK ]; then \
echo "rescue/sh check failed, installation aborted" >&2; \
false; \
fi
.endif
#
# Required install tools to be saved in a scratch dir for safety.
#
.if ${MK_ZONEINFO} != "no"
_zoneinfo= zic tzsetup
.endif
.if !defined(CROSSBUILD_HOST)
_sysctl=sysctl
.endif
ITOOLS= [ awk cap_mkdb cat chflags chmod chown cmp cp \
date echo egrep find grep id install ${_install-info} \
ln make mkdir mtree mv pwd_mkdb \
rm sed services_mkdb sh sort strip ${_sysctl} test time true uname wc \
${_zoneinfo} ${LOCAL_ITOOLS}
# Needed for share/man
.if ${MK_MAN_UTILS} != "no"
ITOOLS+=makewhatis
.endif
#
# distributeworld
#
# Distributes everything compiled by a `buildworld'.
#
# installworld
#
# Installs everything compiled by a 'buildworld'.
#
# Non-base distributions produced by the base system
EXTRA_DISTRIBUTIONS=
.if defined(_LIBCOMPAT)
EXTRA_DISTRIBUTIONS+= lib${libcompat}
.endif
.if ${MK_TESTS} != "no"
EXTRA_DISTRIBUTIONS+= tests
.endif
DEBUG_DISTRIBUTIONS=
.if ${MK_DEBUG_FILES} != "no"
DEBUG_DISTRIBUTIONS+= base ${EXTRA_DISTRIBUTIONS:S,tests,,}
.endif
MTREE_MAGIC?= mtree 2.0
distributeworld installworld stageworld: _installcheck_world .PHONY
mkdir -p ${INSTALLTMP}
progs=$$(for prog in ${ITOOLS}; do \
if progpath=`env PATH=${TMPPATH} which $$prog`; then \
echo $$progpath; \
else \
echo "Required tool $$prog not found in PATH ($$PATH)." >&2; \
exit 1; \
fi; \
done); \
if [ -z "${CROSSBUILD_HOST}" ] ; then \
libs=$$(ldd -f "%o %p\n" -f "%o %p\n" $$progs 2>/dev/null | sort -u | \
while read line; do \
case $$line in \
"["*"]") \
continue;; \
esac; \
set -- $$line; \
if [ "$$2 $$3" != "not found" ]; then \
echo $$2; \
else \
echo "Required library $$1 not found." >&2; \
exit 1; \
fi; \
done); \
fi; \
cp $$libs $$progs ${INSTALLTMP}
cp -R $${PATH_LOCALE:-"/usr/share/locale"} ${INSTALLTMP}/locale
.if defined(NO_ROOT)
-mkdir -p ${METALOG:H}
echo "#${MTREE_MAGIC}" > ${METALOG}
.endif
.if make(distributeworld)
.for dist in ${EXTRA_DISTRIBUTIONS}
-mkdir ${DESTDIR}/${DISTDIR}/${dist}
${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.root.dist \
-p ${DESTDIR}/${DISTDIR}/${dist} >/dev/null
${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
-p ${DESTDIR}/${DISTDIR}/${dist}/usr >/dev/null
${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.include.dist \
-p ${DESTDIR}/${DISTDIR}/${dist}/usr/include >/dev/null
.if ${MK_DEBUG_FILES} != "no"
${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.debug.dist \
-p ${DESTDIR}/${DISTDIR}/${dist}/usr/lib >/dev/null
.endif
.if defined(_LIBCOMPAT)
${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.lib${libcompat}.dist \
-p ${DESTDIR}/${DISTDIR}/${dist}/usr >/dev/null
.if ${MK_DEBUG_FILES} != "no"
${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.lib${libcompat}.dist \
-p ${DESTDIR}/${DISTDIR}/${dist}/usr/lib/debug/usr >/dev/null
.endif
.endif
.if ${MK_TESTS} != "no" && ${dist} == "tests"
-mkdir -p ${DESTDIR}/${DISTDIR}/${dist}${TESTSBASE}
${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.tests.dist \
-p ${DESTDIR}/${DISTDIR}/${dist}${TESTSBASE} >/dev/null
.if ${MK_DEBUG_FILES} != "no"
${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.tests.dist \
-p ${DESTDIR}/${DISTDIR}/${dist}/usr/lib/debug/${TESTSBASE} >/dev/null
.endif
.endif
.if defined(NO_ROOT)
${IMAKEENV} ${DISTR_MTREE} -C -f ${.CURDIR}/etc/mtree/BSD.root.dist | \
sed -e 's#^\./#./${dist}/#' >> ${METALOG}
${IMAKEENV} ${DISTR_MTREE} -C -f ${.CURDIR}/etc/mtree/BSD.usr.dist | \
sed -e 's#^\./#./${dist}/usr/#' >> ${METALOG}
${IMAKEENV} ${DISTR_MTREE} -C -f ${.CURDIR}/etc/mtree/BSD.include.dist | \
sed -e 's#^\./#./${dist}/usr/include/#' >> ${METALOG}
.if defined(_LIBCOMPAT)
${IMAKEENV} ${DISTR_MTREE} -C -f ${.CURDIR}/etc/mtree/BSD.lib${libcompat}.dist | \
sed -e 's#^\./#./${dist}/usr/#' >> ${METALOG}
.endif
.endif
.endfor
-mkdir ${DESTDIR}/${DISTDIR}/base
${_+_}cd ${.CURDIR}/etc; ${CROSSENV} PATH=${TMPPATH} ${MAKE} \
METALOG=${METALOG} ${IMAKE_INSTALL} ${IMAKE_MTREE} \
DISTBASE=/base DESTDIR=${DESTDIR}/${DISTDIR}/base \
LOCAL_MTREE=${LOCAL_MTREE:Q} distrib-dirs
${INSTALL_SYMLINK} ${INSTALLFLAGS} usr/src/sys ${INSTALL_DDIR}/base/sys
.endif # make(distributeworld)
${_+_}cd ${.CURDIR}; ${IMAKE} re${.TARGET:S/world$//}; \
${IMAKEENV} rm -rf ${INSTALLTMP}
.if make(distributeworld)
.for dist in ${EXTRA_DISTRIBUTIONS}
find ${DESTDIR}/${DISTDIR}/${dist} -mindepth 1 -type d -empty -delete
.endfor
.if defined(NO_ROOT)
.for dist in base ${EXTRA_DISTRIBUTIONS}
@# For each file that exists in this dist, print the corresponding
@# line from the METALOG. This relies on the fact that
@# a line containing only the filename will sort immediately before
@# the relevant mtree line.
cd ${DESTDIR}/${DISTDIR}; \
find ./${dist} | sort -u ${METALOG} - | \
awk 'BEGIN { print "#${MTREE_MAGIC}" } !/ type=/ { file = $$1 } / type=/ { if ($$1 == file) { sub(/^\.\/${dist}\//, "./"); print } }' > \
${DESTDIR}/${DISTDIR}/${dist}.meta
.endfor
.for dist in ${DEBUG_DISTRIBUTIONS}
@# For each file that exists in this dist, print the corresponding
@# line from the METALOG. This relies on the fact that
@# a line containing only the filename will sort immediately before
@# the relevant mtree line.
cd ${DESTDIR}/${DISTDIR}; \
find ./${dist}/usr/lib/debug | sort -u ${METALOG} - | \
awk 'BEGIN { print "#${MTREE_MAGIC}" } !/ type=/ { file = $$1 } / type=/ { if ($$1 == file) { sub(/^\.\/${dist}\//, "./"); print } }' > \
${DESTDIR}/${DISTDIR}/${dist}.debug.meta
.endfor
.endif
.endif # make(distributeworld)
.if !make(packageworld) && ${MK_CAROOT} != "no"
@if which openssl>/dev/null; then \
DESTDIR=${CERTCTLDESTDIR} PATH=${TMPPATH}:${PATH} \
sh ${SRCTOP}/usr.sbin/certctl/certctl.sh ${CERTCTLFLAGS} rehash \
else \
echo "No openssl on the host, not rehashing certificates target -- /etc/ssl may not be populated."; \
fi
.endif
packageworld: .PHONY
.for dist in base ${EXTRA_DISTRIBUTIONS}
.if defined(NO_ROOT)
${_+_}cd ${DESTDIR}/${DISTDIR}/${dist}; \
tar cvf - --exclude usr/lib/debug \
@${DESTDIR}/${DISTDIR}/${dist}.meta | \
${XZ_CMD} > ${PACKAGEDIR}/${dist}.txz
.else
${_+_}cd ${DESTDIR}/${DISTDIR}/${dist}; \
tar cvf - --exclude usr/lib/debug . | \
${XZ_CMD} > ${PACKAGEDIR}/${dist}.txz
.endif
.endfor
.for dist in ${DEBUG_DISTRIBUTIONS}
. if defined(NO_ROOT)
${_+_}cd ${DESTDIR}/${DISTDIR}/${dist}; \
tar cvf - @${DESTDIR}/${DISTDIR}/${dist}.debug.meta | \
${XZ_CMD} > ${PACKAGEDIR}/${dist}-dbg.txz
. else
${_+_}cd ${DESTDIR}/${DISTDIR}/${dist}; \
tar cvLf - usr/lib/debug | \
${XZ_CMD} > ${PACKAGEDIR}/${dist}-dbg.txz
. endif
.endfor
makeman: .PHONY
${_+_}cd ${.CURDIR}/tools/build/options; sh makeman > \
${.CURDIR}/share/man/man5/src.conf.5
# Ensure no regressions in self-includeability of sys/*.h and net*/*.h
test-includes: .PHONY
${_+_}cd ${.CURDIR}/tools/build/test-includes; \
${WMAKEENV} ${MAKE} ${WORLD_FLAGS} DESTDIR=${WORLDTMP} test-includes
# We can't assume here that ${TMPPATH} will include ${PATH} or /usr/libexec
# because we may be building with a STRICTTMPPATH, so we explicitly include
# /usr/libexec here for flua. ${TMPPATH} still usefully includes anything else
# we may need to function.
_sysent_PATH= ${TMPPATH}:/usr/libexec
_sysent_dirs= sys/kern
_sysent_dirs+= sys/compat/freebsd32
_sysent_dirs+= sys/amd64/linux \
sys/amd64/linux32 \
sys/arm64/linux \
sys/i386/linux
sysent: .PHONY
.for _dir in ${_sysent_dirs}
sysent-${_dir}: .PHONY
@echo "${MAKE} -C ${.CURDIR}/${_dir} sysent"
${_+_}@env PATH=${_sysent_PATH} ${MAKE} -C ${.CURDIR}/${_dir} sysent
sysent: sysent-${_dir}
.endfor
#
# reinstall
#
# If you have a build server, you can NFS mount the source and obj directories
# and do a 'make reinstall' on the *client* to install new binaries from the
# most recent server build.
#
restage reinstall: .MAKE .PHONY
@echo "--------------------------------------------------------------"
@echo ">>> Making hierarchy"
@echo "--------------------------------------------------------------"
${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 \
LOCAL_MTREE=${LOCAL_MTREE:Q} hierarchy
.if make(restage)
@echo "--------------------------------------------------------------"
@echo ">>> Making distribution"
@echo "--------------------------------------------------------------"
${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 \
LOCAL_MTREE=${LOCAL_MTREE:Q} distribution
.endif
@echo
@echo "--------------------------------------------------------------"
@echo ">>> Installing everything started on `LC_ALL=C date`"
@echo "--------------------------------------------------------------"
${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 install
.if defined(_LIBCOMPAT)
${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 install${libcompat}
.endif
@echo "--------------------------------------------------------------"
@echo ">>> Installing everything completed on `LC_ALL=C date`"
@echo "--------------------------------------------------------------"
redistribute: .MAKE .PHONY
@echo "--------------------------------------------------------------"
@echo ">>> Distributing everything"
@echo "--------------------------------------------------------------"
${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 distribute
.if defined(_LIBCOMPAT)
${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 distribute${libcompat} \
DISTRIBUTION=lib${libcompat}
.endif
distrib-dirs distribution: .MAKE .PHONY
${_+_}cd ${.CURDIR}/etc; ${CROSSENV} PATH=${TMPPATH} ${MAKE} \
${IMAKE_INSTALL} ${IMAKE_MTREE} METALOG=${METALOG} ${.TARGET}
.if make(distribution)
${_+_}cd ${.CURDIR}; ${CROSSENV} PATH=${TMPPATH} \
${MAKE} -f Makefile.inc1 ${IMAKE_INSTALL} \
METALOG=${METALOG} MK_TESTS=no \
MK_TESTS_SUPPORT=${MK_TESTS_SUPPORT} installconfig
.endif
#
# buildkernel and installkernel
#
# Which kernels to build and/or install is specified by setting
# KERNCONF. If not defined a GENERIC kernel is built/installed.
# Only the existing (depending TARGET) config files are used
# for building kernels and only the first of these is designated
# as the one being installed.
#
# Note that we have to use TARGET instead of TARGET_ARCH when
# we're in kernel-land. Since only TARGET_ARCH is (expected) to
# be set to cross-build, we have to make sure TARGET is set
# properly.
.if defined(KERNFAST)
NO_KERNELCLEAN= t
NO_KERNELCONFIG= t
NO_KERNELOBJ= t
# Shortcut for KERNCONF=Blah -DKERNFAST is now KERNFAST=Blah
.if !defined(KERNCONF) && ${KERNFAST} != "1"
KERNCONF=${KERNFAST}
.endif
.endif
.if ${TARGET_ARCH} == "powerpc64"
KERNCONF?= GENERIC64
.elif ${TARGET_ARCH} == "powerpc64le"
KERNCONF?= GENERIC64LE
.elif ${TARGET_ARCH} == "powerpcspe"
KERNCONF?= MPC85XXSPE
.else
KERNCONF?= GENERIC
.endif
INSTKERNNAME?= kernel
KERNSRCDIR?= ${.CURDIR}/sys
KRNLCONFDIR= ${KERNSRCDIR}/${TARGET}/conf
KRNLOBJDIR= ${OBJTOP}${KERNSRCDIR:C,^${.CURDIR},,}
KERNCONFDIR?= ${KRNLCONFDIR}
BUILDKERNELS=
INSTALLKERNEL=
.if defined(NO_INSTALLKERNEL)
# All of the BUILDKERNELS loops start at index 1.
BUILDKERNELS+= dummy
.endif
.for _kernel in ${KERNCONF}
.if !defined(_MKSHOWCONFIG) && exists(${KERNCONFDIR}/${_kernel})
BUILDKERNELS+= ${_kernel}
.if empty(INSTALLKERNEL) && !defined(NO_INSTALLKERNEL)
INSTALLKERNEL= ${_kernel}
.endif
.else
.if make(buildkernel)
.error Missing KERNCONF ${KERNCONFDIR}/${_kernel}
.endif
.endif
.endfor
_cleankernobj_fast_depend_hack: .PHONY
# 20191009 r353340 removal of opensolaris_atomic.S (also r353381)
.if ${MACHINE} != i386
.for f in opensolaris_atomic
.for m in opensolaris zfs
@if [ -e "${KRNLOBJDIR}/${KERNCONF}/modules${SRCTOP}/sys/modules/${m}/.depend.${f}.o" ] && \
grep -q ${f}.S "${KRNLOBJDIR}/${KERNCONF}/modules${SRCTOP}/sys/modules/${m}/.depend.${f}.o"; then \
echo "Removing stale dependencies for opensolaris_atomic"; \
rm -f ${KRNLOBJDIR}/${KERNCONF}/modules${SRCTOP}/sys/modules/${m}/.depend.${f}.*; \
fi
.endfor
.endfor
.endif
${WMAKE_TGTS:N_worldtmp:Nbuild${libcompat}} ${.ALLTARGETS:M_*:N_worldtmp}: .MAKE .PHONY
# record kernel(s) build time in seconds
.if make(buildkernel)
_BUILDKERNEL_START!= date '+%s'
.endif
#
# buildkernel
#
# Builds all kernels defined by BUILDKERNELS.
#
buildkernel: .MAKE .PHONY
.if empty(BUILDKERNELS:Ndummy)
@echo "ERROR: Missing kernel configuration file(s) (${KERNCONF})."; \
false
.endif
@echo
.for _kernel in ${BUILDKERNELS:Ndummy}
@echo "--------------------------------------------------------------"
@echo ">>> Kernel build for ${_kernel} started on `LC_ALL=C date`"
@echo "--------------------------------------------------------------"
@echo "===> ${_kernel}"
mkdir -p ${KRNLOBJDIR}
.if !defined(NO_KERNELCONFIG)
@echo
@echo "--------------------------------------------------------------"
@echo ">>> stage 1: configuring the kernel"
@echo "--------------------------------------------------------------"
cd ${KRNLCONFDIR}; \
PATH=${TMPPATH} \
config ${CONFIGARGS} -d ${KRNLOBJDIR}/${_kernel} \
-I '${KERNCONFDIR}' -I '${KRNLCONFDIR}' \
'${KERNCONFDIR}/${_kernel}'
.endif
.if ${MK_CLEAN} == "yes" && !defined(NO_KERNELCLEAN)
@echo
@echo "--------------------------------------------------------------"
@echo ">>> stage 2.1: cleaning up the object tree"
@echo "--------------------------------------------------------------"
${_+_}cd ${KRNLOBJDIR}/${_kernel}; ${KMAKE} ${CLEANDIR}
.else
${_+_}cd ${.CURDIR}; ${WMAKE} _cleankernobj_fast_depend_hack
.endif
.if !defined(NO_KERNELOBJ)
@echo
@echo "--------------------------------------------------------------"
@echo ">>> stage 2.2: rebuilding the object tree"
@echo "--------------------------------------------------------------"
${_+_}cd ${KRNLOBJDIR}/${_kernel}; ${KMAKE} obj
.endif
@echo
@echo "--------------------------------------------------------------"
@echo ">>> stage 2.3: build tools"
@echo "--------------------------------------------------------------"
${_+_}cd ${.CURDIR}; ${KTMAKE} kernel-tools
@echo
@echo "--------------------------------------------------------------"
@echo ">>> stage 3.1: building everything"
@echo "--------------------------------------------------------------"
${_+_}cd ${KRNLOBJDIR}/${_kernel}; ${KMAKE} all -DNO_MODULES_OBJ
@echo "--------------------------------------------------------------"
@echo ">>> Kernel build for ${_kernel} completed on `LC_ALL=C date`"
@echo "--------------------------------------------------------------"
.endfor
@seconds=$$(($$(date '+%s') - ${_BUILDKERNEL_START})); \
echo -n ">>> Kernel(s) ${BUILDKERNELS} built in $$seconds seconds, "; \
echo "ncpu: $$(${_ncpu_cmd})${.MAKE.JOBS:S/^/, make -j/}"
@echo "--------------------------------------------------------------"
.if !make(packages) && !make(update-packages)
NO_INSTALLEXTRAKERNELS?= yes
.else
# packages/update-packages installs kernels to a staging directory then builds
# packages from the result to be installed, typically to other systems. It is
# less surprising for these targets to honor KERNCONF if multiple kernels are
# specified.
NO_INSTALLEXTRAKERNELS?= no
.endif
#
# installkernel, etc.
#
# Install the kernel defined by INSTALLKERNEL
#
installkernel installkernel.debug \
reinstallkernel reinstallkernel.debug: _installcheck_kernel .PHONY
.if !defined(NO_INSTALLKERNEL)
.if empty(INSTALLKERNEL)
@echo "ERROR: No kernel \"${KERNCONF}\" to install."; \
false
.endif
@echo "--------------------------------------------------------------"
@echo ">>> Installing kernel ${INSTALLKERNEL} on $$(LC_ALL=C date)"
@echo "--------------------------------------------------------------"
${_+_}cd ${KRNLOBJDIR}/${INSTALLKERNEL}; \
${CROSSENV} PATH=${TMPPATH} \
${MAKE} ${IMAKE_INSTALL} KERNEL=${INSTKERNNAME} ${.TARGET:S/kernel//}
@echo "--------------------------------------------------------------"
@echo ">>> Installing kernel ${INSTALLKERNEL} completed on $$(LC_ALL=C date)"
@echo "--------------------------------------------------------------"
.endif
.if ${BUILDKERNELS:[#]} > 1 && ${NO_INSTALLEXTRAKERNELS} != "yes"
.for _kernel in ${BUILDKERNELS:[2..-1]}
@echo "--------------------------------------------------------------"
@echo ">>> Installing kernel ${_kernel} $$(LC_ALL=C date)"
@echo "--------------------------------------------------------------"
${_+_}cd ${KRNLOBJDIR}/${_kernel}; \
${CROSSENV} PATH=${TMPPATH} \
${MAKE} ${IMAKE_INSTALL} KERNEL=${INSTKERNNAME}.${_kernel} ${.TARGET:S/kernel//}
@echo "--------------------------------------------------------------"
@echo ">>> Installing kernel ${_kernel} completed on $$(LC_ALL=C date)"
@echo "--------------------------------------------------------------"
.endfor
.endif
distributekernel distributekernel.debug: .PHONY
.if !defined(NO_INSTALLKERNEL)
.if empty(INSTALLKERNEL)
@echo "ERROR: No kernel \"${KERNCONF}\" to install."; \
false
.endif
mkdir -p ${DESTDIR}/${DISTDIR}
.if defined(NO_ROOT)
@echo "#${MTREE_MAGIC}" > ${DESTDIR}/${DISTDIR}/kernel.premeta
.endif
${_+_}cd ${KRNLOBJDIR}/${INSTALLKERNEL}; \
${IMAKEENV} ${IMAKE_INSTALL:S/METALOG/kernel.premeta/} \
${IMAKE_MTREE} PATH=${TMPPATH} ${MAKE} KERNEL=${INSTKERNNAME} \
DESTDIR=${INSTALL_DDIR}/kernel \
${.TARGET:S/distributekernel/install/}
.if defined(NO_ROOT)
@sed -e 's|^./kernel|.|' ${DESTDIR}/${DISTDIR}/kernel.premeta > \
${DESTDIR}/${DISTDIR}/kernel.meta
.endif
.endif
.if ${BUILDKERNELS:[#]} > 1 && ${NO_INSTALLEXTRAKERNELS} != "yes"
.for _kernel in ${BUILDKERNELS:[2..-1]}
.if defined(NO_ROOT)
@echo "#${MTREE_MAGIC}" > ${DESTDIR}/${DISTDIR}/kernel.${_kernel}.premeta
.endif
${_+_}cd ${KRNLOBJDIR}/${_kernel}; \
${IMAKEENV} ${IMAKE_INSTALL:S/METALOG/kernel.${_kernel}.premeta/} \
${IMAKE_MTREE} PATH=${TMPPATH} ${MAKE} \
KERNEL=${INSTKERNNAME}.${_kernel} \
DESTDIR=${INSTALL_DDIR}/kernel.${_kernel} \
${.TARGET:S/distributekernel/install/}
.if defined(NO_ROOT)
@sed -e "s|^./kernel.${_kernel}|.|" \
${DESTDIR}/${DISTDIR}/kernel.${_kernel}.premeta > \
${DESTDIR}/${DISTDIR}/kernel.${_kernel}.meta
.endif
.endfor
.endif
packagekernel: .PHONY
.if defined(NO_ROOT)
.if !defined(NO_INSTALLKERNEL)
cd ${DESTDIR}/${DISTDIR}/kernel; \
tar cvf - --exclude '*.debug' \
@${DESTDIR}/${DISTDIR}/kernel.meta | \
${XZ_CMD} > ${PACKAGEDIR}/kernel.txz
.endif
.if ${MK_DEBUG_FILES} != "no"
cd ${DESTDIR}/${DISTDIR}/kernel; \
tar cvf - --include '*/*/*.debug' \
@${DESTDIR}/${DISTDIR}/kernel.meta | \
${XZ_CMD} > ${DESTDIR}/${DISTDIR}/kernel-dbg.txz
.endif
.if ${BUILDKERNELS:[#]} > 1 && ${NO_INSTALLEXTRAKERNELS} != "yes"
.for _kernel in ${BUILDKERNELS:[2..-1]}
cd ${DESTDIR}/${DISTDIR}/kernel.${_kernel}; \
tar cvf - --exclude '*.debug' \
@${DESTDIR}/${DISTDIR}/kernel.${_kernel}.meta | \
${XZ_CMD} > ${PACKAGEDIR}/kernel.${_kernel}.txz
.if ${MK_DEBUG_FILES} != "no"
cd ${DESTDIR}/${DISTDIR}/kernel.${_kernel}; \
tar cvf - --include '*/*/*.debug' \
@${DESTDIR}/${DISTDIR}/kernel.${_kernel}.meta | \
${XZ_CMD} > ${DESTDIR}/${DISTDIR}/kernel.${_kernel}-dbg.txz
.endif
.endfor
.endif
.else
.if !defined(NO_INSTALLKERNEL)
cd ${DESTDIR}/${DISTDIR}/kernel; \
tar cvf - --exclude '*.debug' . | \
${XZ_CMD} > ${PACKAGEDIR}/kernel.txz
.endif
.if ${MK_DEBUG_FILES} != "no"
cd ${DESTDIR}/${DISTDIR}/kernel; \
tar cvf - --include '*/*/*.debug' $$(eval find .) | \
${XZ_CMD} > ${DESTDIR}/${DISTDIR}/kernel-dbg.txz
.endif
.if ${BUILDKERNELS:[#]} > 1 && ${NO_INSTALLEXTRAKERNELS} != "yes"
.for _kernel in ${BUILDKERNELS:[2..-1]}
cd ${DESTDIR}/${DISTDIR}/kernel.${_kernel}; \
tar cvf - --exclude '*.debug' . | \
${XZ_CMD} > ${PACKAGEDIR}/kernel.${_kernel}.txz
.if ${MK_DEBUG_FILES} != "no"
cd ${DESTDIR}/${DISTDIR}/kernel.${_kernel}; \
tar cvf - --include '*/*/*.debug' $$(eval find .) | \
${XZ_CMD} > ${DESTDIR}/${DISTDIR}/kernel.${_kernel}-dbg.txz
.endif
.endfor
.endif
.endif
stagekernel: .PHONY
${_+_}${MAKE} -C ${.CURDIR} ${.MAKEFLAGS} distributekernel
PORTSDIR?= /usr/ports
WSTAGEDIR?= ${OBJTOP}/worldstage
KSTAGEDIR?= ${OBJTOP}/kernelstage
REPODIR?= ${OBJROOT}repo
PKG_FORMAT?= txz
PKG_REPO_SIGNING_KEY?= # empty
PKG_OUTPUT_DIR?= ${PKG_VERSION}
.ORDER: stage-packages create-packages
.ORDER: create-packages create-world-packages
.ORDER: create-packages create-kernel-packages
.ORDER: create-packages sign-packages
_pkgbootstrap: .PHONY
.if make(*package*) && !exists(${LOCALBASE}/sbin/pkg)
@env ASSUME_ALWAYS_YES=YES pkg bootstrap
.endif
#
# Determine PKG_ABI from newvers.sh if not already set.
#
.if !defined(PKG_ABI) && (make(create-world-packages-jobs) || make(create-kernel-packages*) || make(real-update-packages) || make(sign-packages))
PKG_ABI=${_TYPE}:${_REVISION:S/\..*$//}:${TARGET_ARCH}
.endif
PKG_BIN_VERSION!=${PKG_CMD} --version </dev/null 2>/dev/null |\
awk -F. '/^[0-9.]+$$/ {print $$1 * 10000 + $$2 * 100 + $$3}'
.if ${PKG_BIN_VERSION} < 11700
PKG_EXT= ${PKG_FORMAT}
.else
PKG_EXT= pkg
.endif
.if !defined(PKG_VERSION_FROM) && make(real-update-packages)
.if defined(PKG_ABI)
.if exists(${REPODIR}/${PKG_ABI})
PKG_VERSION_FROM!=/usr/bin/readlink ${REPODIR}/${PKG_ABI}/latest
PKG_VERSION_FROM_DIR= ${REPODIR}/${PKG_ABI}/${PKG_VERSION_FROM}
.else
PKG_VERSION_FROM=
PKG_VERSION_FROM_DIR=
.endif
.endif
.endif
PKGMAKEARGS+= PKG_VERSION=${PKG_VERSION} \
NO_INSTALLEXTRAKERNELS=${NO_INSTALLEXTRAKERNELS}
packages: .PHONY
${_+_}${MAKE} -C ${.CURDIR} ${PKGMAKEARGS} real-packages
update-packages: .PHONY
${_+_}${MAKE} -C ${.CURDIR} ${PKGMAKEARGS} real-update-packages
package-pkg: .PHONY
rm -rf /tmp/ports.${TARGET} || :
env ${WMAKEENV:Q} SRCDIR=${.CURDIR} PORTSDIR=${PORTSDIR} REVISION=${_REVISION} \
PKG_CMD=${PKG_CMD} PKG_VERSION=${PKG_VERSION} REPODIR=${REPODIR} \
WSTAGEDIR=${WSTAGEDIR} \
sh ${.CURDIR}/release/scripts/make-pkg-package.sh
real-packages: stage-packages create-packages sign-packages .PHONY
real-update-packages: stage-packages .PHONY
${_+_}${MAKE} -C ${.CURDIR} PKG_VERSION=${PKG_VERSION} create-packages
.if empty(PKG_VERSION_FROM_DIR)
@echo "==> Bootstrapping repository, not checking for new packages"
.else
@echo "==> Checking for new packages (comparing ${PKG_VERSION} to ${PKG_VERSION_FROM})"
@for pkg in ${PKG_VERSION_FROM_DIR}/${PKG_NAME_PREFIX}-*; do \
pkgname=$$(pkg query -F $${pkg} '%n' | sed 's/${PKG_NAME_PREFIX}-\(.*\)/\1/') ; \
newpkgname=${PKG_NAME_PREFIX}-$${pkgname}-${PKG_VERSION}.${PKG_EXT} ; \
oldsum=$$(pkg query -F $${pkg} '%X') ; \
if [ ! -f ${REPODIR}/${PKG_ABI}/${PKG_VERSION}/$${newpkgname} ]; then \
continue; \
fi ; \
newsum=$$(pkg query -F ${REPODIR}/${PKG_ABI}/${PKG_VERSION}/$${newpkgname} '%X') ; \
if [ "$${oldsum}" == "$${newsum}" ]; then \
echo "==> Keeping old ${PKG_NAME_PREFIX}-$${pkgname}-${PKG_VERSION_FROM}.${PKG_EXT}" ; \
rm ${REPODIR}/${PKG_ABI}/${PKG_VERSION}/$${newpkgname} ; \
cp $${pkg} ${REPODIR}/${PKG_ABI}/${PKG_VERSION} ; \
else \
echo "==> New package $${newpkgname}" ; \
fi ; \
done
.endif
${_+_}@cd ${.CURDIR}; \
${MAKE} -f Makefile.inc1 PKG_VERSION=${PKG_VERSION} sign-packages
stage-packages-world: .PHONY
@mkdir -p ${WSTAGEDIR}
${_+_}@cd ${.CURDIR}; \
${MAKE} DESTDIR=${WSTAGEDIR} -DNO_ROOT stageworld
stage-packages-kernel: .PHONY
@mkdir -p ${KSTAGEDIR}
${_+_}@cd ${.CURDIR}; \
${MAKE} DESTDIR=${KSTAGEDIR} -DNO_ROOT stagekernel
stage-packages: .PHONY stage-packages-world stage-packages-kernel
_repodir: .PHONY
@mkdir -p ${REPODIR}
create-packages-world: _pkgbootstrap _repodir .PHONY
${_+_}@cd ${.CURDIR}; \
${MAKE} -f Makefile.inc1 \
DESTDIR=${WSTAGEDIR} \
PKG_VERSION=${PKG_VERSION} create-world-packages
create-packages-kernel: _pkgbootstrap _repodir .PHONY
${_+_}@cd ${.CURDIR}; \
${MAKE} -f Makefile.inc1 \
DESTDIR=${KSTAGEDIR} \
PKG_VERSION=${PKG_VERSION} DISTDIR=kernel \
SOURCE_DATE_EPOCH=${SOURCE_DATE_EPOCH} \
create-kernel-packages
create-packages: .PHONY create-packages-world create-packages-kernel
create-world-packages: _pkgbootstrap .PHONY
@rm -f ${WSTAGEDIR}/*.plist 2>/dev/null || :
@cd ${WSTAGEDIR} ; \
env -i LC_COLLATE=C sort ${WSTAGEDIR}/${DISTDIR}/METALOG | \
awk -f ${SRCDIR}/release/scripts/mtree-to-plist.awk
@for plist in ${WSTAGEDIR}/*.plist; do \
plist=$${plist##*/} ; \
pkgname=$${plist%.plist} ; \
echo "_PKGS+= $${pkgname}" ; \
done > ${WSTAGEDIR}/packages.mk
${_+_}@cd ${.CURDIR}; \
${MAKE} -f Makefile.inc1 create-world-packages-jobs \
SOURCE_DATE_EPOCH=${SOURCE_DATE_EPOCH} \
.MAKE.JOB.PREFIX=
.if make(create-world-packages-jobs)
.include "${WSTAGEDIR}/packages.mk"
.endif
create-world-packages-jobs: .PHONY
.for pkgname in ${_PKGS}
create-world-packages-jobs: create-world-package-${pkgname}
create-world-package-${pkgname}: .PHONY
@sh ${SRCDIR}/release/packages/generate-ucl.sh -o ${pkgname} \
-s ${SRCDIR} -u ${WSTAGEDIR}/${pkgname}.ucl
@awk -F\" ' \
/^name/ { printf("===> Creating %s-", $$2); next } \
/^version/ { print $$2; next } \
' ${WSTAGEDIR}/${pkgname}.ucl
@if [ "${pkgname}" == "runtime" ]; then \
sed -i '' -e "s/%VCS_REVISION%/${VCS_REVISION}/" ${WSTAGEDIR}/${pkgname}.ucl ; \
fi
${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/usr/bin/uname -o ALLOW_BASE_SHLIBS=yes \
create -f ${PKG_FORMAT} -M ${WSTAGEDIR}/${pkgname}.ucl \
-p ${WSTAGEDIR}/${pkgname}.plist \
-r ${WSTAGEDIR} \
-o ${REPODIR}/${PKG_ABI}/${PKG_OUTPUT_DIR}
.endfor
_default_flavor= -default
.if make(*package*) && exists(${KSTAGEDIR}/kernel.meta)
. if ${MK_DEBUG_FILES} != "no"
_debug=-dbg
. endif
create-kernel-packages: .PHONY
. for flavor in "" ${_debug}
create-kernel-packages: create-kernel-packages-flavor${flavor:C,^""$,${_default_flavor},}
create-kernel-packages-flavor${flavor:C,^""$,${_default_flavor},}: _pkgbootstrap .PHONY
@cd ${KSTAGEDIR}/${DISTDIR} ; \
env -i LC_COLLATE=C sort ${KSTAGEDIR}/kernel.meta | \
awk -f ${SRCDIR}/release/scripts/mtree-to-plist.awk \
-v kernel=yes -v _kernconf=${INSTALLKERNEL} ; \
sed -e "s/%VERSION%/${PKG_VERSION}/" \
-e "s/%PKGNAME%/kernel-${INSTALLKERNEL:tl}${flavor}/" \
-e "s/%KERNELDIR%/kernel/" \
-e "s/%COMMENT%/FreeBSD ${INSTALLKERNEL} kernel ${flavor}/" \
-e "s/%DESC%/FreeBSD ${INSTALLKERNEL} kernel ${flavor}/" \
-e "s/ %VCS_REVISION%/${VCS_REVISION}/" \
-e "s/%PKG_NAME_PREFIX%/${PKG_NAME_PREFIX}/" \
-e "s/%PKG_MAINTAINER%/${PKG_MAINTAINER}/" \
-e "s|%PKG_WWW%|${PKG_WWW}|" \
${SRCDIR}/release/packages/kernel.ucl \
> ${KSTAGEDIR}/${DISTDIR}/kernel.${INSTALLKERNEL}${flavor}.ucl ; \
awk -F\" ' \
/name/ { printf("===> Creating %s-", $$2); next } \
/version/ {print $$2; next } ' \
${KSTAGEDIR}/${DISTDIR}/kernel.${INSTALLKERNEL}${flavor}.ucl ; \
${PKG_CMD} -o ABI=${PKG_ABI} -o ALLOW_BASE_SHLIBS=yes \
create -f ${PKG_FORMAT} \
-M ${KSTAGEDIR}/${DISTDIR}/kernel.${INSTALLKERNEL}${flavor}.ucl \
-p ${KSTAGEDIR}/${DISTDIR}/kernel.${INSTALLKERNEL}${flavor}.plist \
-r ${KSTAGEDIR}/${DISTDIR} \
-o ${REPODIR}/${PKG_ABI}/${PKG_OUTPUT_DIR}
. endfor
.endif
.if ${BUILDKERNELS:[#]} > 1 && ${NO_INSTALLEXTRAKERNELS} != "yes"
. for _kernel in ${BUILDKERNELS:[2..-1]}
. if exists(${KSTAGEDIR}/kernel.${_kernel}.meta)
. if ${MK_DEBUG_FILES} != "no"
_debug=-dbg
. endif
. for flavor in "" ${_debug}
create-kernel-packages: create-kernel-packages-extra-flavor${flavor:C,^""$,${_default_flavor},}-${_kernel}
create-kernel-packages-extra-flavor${flavor:C,^""$,${_default_flavor},}-${_kernel}: _pkgbootstrap .PHONY
@cd ${KSTAGEDIR}/kernel.${_kernel} ; \
env -i LC_COLLATE=C sort ${KSTAGEDIR}/kernel.${_kernel}.meta | \
awk -f ${SRCDIR}/release/scripts/mtree-to-plist.awk \
-v kernel=yes -v _kernconf=${_kernel} ; \
sed -e "s/%VERSION%/${PKG_VERSION}/" \
-e "s/%PKGNAME%/kernel-${_kernel:tl}${flavor}/" \
-e "s/%KERNELDIR%/kernel.${_kernel}/" \
-e "s/%COMMENT%/FreeBSD ${_kernel} kernel ${flavor}/" \
-e "s/%DESC%/FreeBSD ${_kernel} kernel ${flavor}/" \
-e "s/ %VCS_REVISION%/${VCS_REVISION}/" \
-e "s/%PKG_NAME_PREFIX%/${PKG_NAME_PREFIX}/" \
-e "s/%PKG_MAINTAINER%/${PKG_MAINTAINER}/" \
-e "s|%PKG_WWW%|${PKG_WWW}|" \
${SRCDIR}/release/packages/kernel.ucl \
> ${KSTAGEDIR}/kernel.${_kernel}/kernel.${_kernel}${flavor}.ucl ; \
awk -F\" ' \
/name/ { printf("===> Creating %s-", $$2); next } \
/version/ {print $$2; next } ' \
${KSTAGEDIR}/kernel.${_kernel}/kernel.${_kernel}${flavor}.ucl ; \
${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/usr/bin/uname -o ALLOW_BASE_SHLIBS=yes \
create -f ${PKG_FORMAT} \
-M ${KSTAGEDIR}/kernel.${_kernel}/kernel.${_kernel}${flavor}.ucl \
-p ${KSTAGEDIR}/kernel.${_kernel}/kernel.${_kernel}${flavor}.plist \
-r ${KSTAGEDIR}/kernel.${_kernel} \
-o ${REPODIR}/${PKG_ABI}/${PKG_OUTPUT_DIR}
. endfor
. endif
. endfor
.endif
sign-packages: _pkgbootstrap .PHONY
printf "version = 2;\n" > ${WSTAGEDIR}/meta
.if ${PKG_BIN_VERSION} < 11700
printf "packing_format = \"${PKG_FORMAT}\";\n" >> ${WSTAGEDIR}/meta
.endif
@[ -L "${REPODIR}/$$(${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/usr/bin/uname config ABI)/latest" ] && \
unlink ${REPODIR}/$$(${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/usr/bin/uname config ABI)/latest ; \
${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/usr/bin/uname repo \
-m ${WSTAGEDIR}/meta \
-o ${REPODIR}/$$(${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/usr/bin/uname config ABI)/${PKG_VERSION} \
${REPODIR}/$$(${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/usr/bin/uname config ABI)/${PKG_VERSION} \
${PKG_REPO_SIGNING_KEY} ; \
cd ${REPODIR}/$$(${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/usr/bin/uname config ABI); \
ln -s ${PKG_OUTPUT_DIR} latest
#
#
# checkworld
#
# Run test suite on installed world.
#
checkworld: .PHONY
@if [ ! -x "${LOCALBASE}/bin/kyua" ] && [ ! -x "/usr/bin/kyua" ]; then \
echo "You need kyua (devel/kyua) to run the test suite." | /usr/bin/fmt; \
exit 1; \
fi
${_+_}PATH="$$PATH:${LOCALBASE}/bin" kyua test -k ${TESTSBASE}/Kyuafile
#
#
# doxygen
#
# Build the API documentation with doxygen
#
doxygen: .PHONY
@if [ ! -x "${LOCALBASE}/bin/doxygen" ]; then \
echo "You need doxygen (devel/doxygen) to generate the API documentation of the kernel." | /usr/bin/fmt; \
exit 1; \
fi
${_+_}cd ${.CURDIR}/tools/kerneldoc/subsys; ${MAKE} obj all
#
# ------------------------------------------------------------------------
#
# From here onwards are utility targets used by the 'make world' and
# related targets. If your 'world' breaks, you may like to try to fix
# the problem and manually run the following targets to attempt to
# complete the build. Beware, this is *not* guaranteed to work, you
# need to have a pretty good grip on the current state of the system
# to attempt to manually finish it. If in doubt, 'make world' again.
#
#
# legacy: Build compatibility shims for the next three targets. This is a
# minimal set of tools and shims necessary to compensate for older systems
# which don't have the APIs required by the targets built in bootstrap-tools,
# build-tools or cross-tools.
#
legacy: .PHONY
.if ${BOOTSTRAPPING} < ${MINIMUM_SUPPORTED_OSREL} && ${BOOTSTRAPPING} != 0
@echo "ERROR: Source upgrades from versions prior to ${MINIMUM_SUPPORTED_REL} are not supported."; \
false
.endif
.for _tool in \
tools/build \
${LOCAL_LEGACY_DIRS}
${_+_}@${ECHODIR} "===> ${_tool} (obj,includes,all,install)"; \
cd ${.CURDIR}/${_tool}; \
if [ -z "${NO_OBJWALK}" ]; then ${MAKE} DIRPRFX=${_tool}/ obj; fi; \
${MAKE} DIRPRFX=${_tool}/ DESTDIR=${WORLDTMP}/legacy includes; \
${MAKE} DIRPRFX=${_tool}/ MK_INCLUDES=no all; \
${MAKE} DIRPRFX=${_tool}/ MK_INCLUDES=no \
DESTDIR=${WORLDTMP}/legacy install
.endfor
#
# bootstrap-tools: Build tools needed for compatibility. These are binaries that
# are built to build other binaries in the system. However, the focus of these
# binaries is usually quite narrow. Bootstrap tools use the host's compiler and
# libraries, augmented by -legacy, in addition to the libraries built during
# bootstrap-tools.
#
_bt= _bootstrap-tools
# We want to run the build with only ${WORLDTMP} in $PATH to ensure we don't
# accidentally run tools that are incompatible but happen to be in $PATH.
# This is especially important when building on Linux/MacOS where many of the
# programs used during the build accept different flags or generate different
# output. On those platforms we only symlink the tools known to be compatible
# (e.g. basic utilities such as mkdir) into ${WORLDTMP} and build all others
# from the FreeBSD sources during the bootstrap-tools stage.
# We want to build without the user's $PATH starting in the bootstrap-tools
# phase so the tools used in that phase (ln, cp, etc) must have already been
# linked to $WORLDTMP. The tools are listed in the _host_tools_to_symlink
# variable in tools/build/Makefile and are linked during the legacy phase.
# Since they could be Linux or MacOS binaries, too we must only use flags that
# are portable across operating systems.
# If BOOTSTRAP_ALL_TOOLS is set we will build all the required tools from the
# current source tree. Otherwise we create a symlink to the version found in
# $PATH during the bootstrap-tools stage.
# When building on non-FreeBSD systems we can't assume that the host binaries
# accept compatible flags or produce compatible output. Therefore we force
# BOOTSTRAP_ALL_TOOLS and just build the FreeBSD version of the binary.
.if defined(CROSSBUILD_HOST)
BOOTSTRAP_ALL_TOOLS:= 1
.endif
.if defined(BOOTSTRAP_ALL_TOOLS)
# BOOTSTRAPPING will be set on the command line so we can't override it here.
# Instead set BOOTSTRAPPING_OSRELDATE so that the value 0 is set ${BSARGS}
BOOTSTRAPPING_OSRELDATE:= 0
.endif
# libnv and libsbuf are requirements for config(8), which is an unconditional
# bootstrap-tool.
_config=usr.sbin/config lib/libnv lib/libsbuf
${_bt}-usr.sbin/config: ${_bt}-lib/libnv ${_bt}-lib/libsbuf
.if ${MK_GAMES} != "no"
_strfile= usr.bin/fortune/strfile
.endif
# vtfontcvt is used to build font files for loader and to generate
# C source for loader built in font (8x16.c).
_vtfontcvt= usr.bin/vtfontcvt
# If we are not building the bootstrap because BOOTSTRAPPING is sufficient
# we symlink the host version to $WORLDTMP instead. By doing this we can also
# detect when a bootstrap tool is being used without the required MK_FOO.
# If you add a new bootstrap tool where we could also use the host version,
# please ensure that you also add a .else case where you add the tool to the
# _bootstrap_tools_links variable.
.if ${BOOTSTRAPPING} < 1000033
# Note: lex needs m4 to build but m4 also depends on lex (which needs m4 to
# generate any files). To fix this cyclic dependency we can build a bootstrap
# version of m4 (with pre-generated files) then use that to build the real m4.
# We can't simply use the host m4 since e.g. the macOS version does not accept
# the flags that are passed by lex.
# For lex we also use the pre-gerated files since we would otherwise need to
# build awk and sed first (which need lex to build)
# TODO: add a _bootstrap_lex and then build the real lex afterwards
_lex= usr.bin/lex
_m4= tools/build/bootstrap-m4 usr.bin/m4
${_bt}-tools/build/bootstrap-m4: ${_bt}-usr.bin/lex ${_bt}-lib/libopenbsd ${_bt}-usr.bin/yacc
${_bt}-usr.bin/m4: ${_bt}-lib/libopenbsd ${_bt}-usr.bin/yacc ${_bt}-usr.bin/lex ${_bt}-tools/build/bootstrap-m4
_bt_m4_depend=${_bt}-usr.bin/m4
_bt_lex_depend=${_bt}-usr.bin/lex ${_bt_m4_depend}
.else
_bootstrap_tools_links+=m4 lex
.endif
# ELF Tool Chain libraries are needed for ELF tools and dtrace tools.
# r296685 fix cross-endian objcopy
# r310724 fixed PR 215350, a crash in libdwarf with objects built by GCC 6.2.
# r334881 added libdwarf constants used by ctfconvert.
# r338478 fixed a crash in objcopy for mips64el objects
# r339083 libelf: correct mips64el test to use ELF header
# r348347 Add missing powerpc64 relocation support to libdwarf
.if ${BOOTSTRAPPING} < 1300030
_elftoolchain_libs= lib/libelf lib/libdwarf lib/libzstd
${_bt}-lib/libelf: ${_bt_m4_depend}
${_bt}-lib/libdwarf: ${_bt_m4_depend}
.endif
# flua is required to regenerate syscall files. It first appeared during the
# 13.0-CURRENT cycle, thus needs to be built on -older releases and stable
# branches.
.if ${BOOTSTRAPPING} < 1300059
${_bt}-libexec/flua: ${_bt}-lib/liblua ${_bt}-lib/libucl
_flua= lib/liblua lib/libucl libexec/flua
.endif
# r245440 mtree -N support added
# r313404 requires sha384.h for libnetbsd, added to libmd in r292782
.if ${BOOTSTRAPPING} < 1100093
_nmtree= lib/libmd \
lib/libnetbsd \
usr.sbin/nmtree
${_bt}-lib/libnetbsd: ${_bt}-lib/libmd
${_bt}-usr.sbin/nmtree: ${_bt}-lib/libnetbsd
.else
_bootstrap_tools_links+=mtree
.endif
# r246097: log addition login.conf.db, passwd, pwd.db, and spwd.db with cat -l
.if ${BOOTSTRAPPING} < 1000027
_cat= bin/cat
.else
_bootstrap_tools_links+=cat
.endif
# r277259 crunchide: Correct 64-bit section header offset
# r281674 crunchide: always include both 32- and 64-bit ELF support
.if ${BOOTSTRAPPING} < 1100078
_crunchide= usr.sbin/crunch/crunchide
.else
_bootstrap_tools_links+=crunchide
.endif
# 1300115: Higher WARNS fixes
.if ${BOOTSTRAPPING} < 1202502 || \
(${BOOTSTRAPPING} > 1300000 && ${BOOTSTRAPPING} < 1300131)
_crunchgen= usr.sbin/crunch/crunchgen
.else
_bootstrap_tools_links+=crunchgen
.endif
# 1300102: VHDX support
.if ${BOOTSTRAPPING} < 1201520 || \
(${BOOTSTRAPPING} > 1300000 && ${BOOTSTRAPPING} < 1300102)
_mkimg= usr.bin/mkimg
.else
_bootstrap_tools_links+=mkimg
.endif
_yacc= usr.bin/yacc
.if ${MK_BSNMP} != "no"
_gensnmptree= usr.sbin/bsnmpd/gensnmptree
.endif
# We need to build tblgen when we're building clang or lld, either as
# bootstrap tools, or as the part of the normal build.
# llvm-tblgen is also needed for various llvm binutils (e.g. objcopy).
.if ${MK_CLANG_BOOTSTRAP} != "no" || ${MK_CLANG} != "no" || \
${MK_LLD_BOOTSTRAP} != "no" || ${MK_LLD} != "no" || \
${MK_LLDB} != "no" || ${MK_LLVM_BINUTILS} != "no"
_clang_tblgen= \
lib/clang/libllvmminimal \
usr.bin/clang/llvm-tblgen
.if ${MK_CLANG_BOOTSTRAP} != "no" || ${MK_CLANG} != "no" || \
${MK_LLDB} != "no"
_clang_tblgen+= usr.bin/clang/clang-tblgen
.endif
.if ${MK_LLDB} != "no"
_clang_tblgen+= usr.bin/clang/lldb-tblgen
.endif
${_bt}-usr.bin/clang/clang-tblgen: ${_bt}-lib/clang/libllvmminimal
${_bt}-usr.bin/clang/llvm-tblgen: ${_bt}-lib/clang/libllvmminimal
${_bt}-usr.bin/clang/lldb-tblgen: ${_bt}-lib/clang/libllvmminimal
.endif
# C.UTF-8 is always built in share/ctypes and we need localedef for that.
_localedef= usr.bin/localedef
${_bt}-usr.bin/localedef: ${_bt}-usr.bin/yacc ${_bt_lex_depend}
.if ${MK_ICONV} != "no"
_mkesdb= usr.bin/mkesdb
_mkcsmapper= usr.bin/mkcsmapper
${_bt}-usr.bin/mkesdb: ${_bt}-usr.bin/yacc ${_bt_lex_depend}
${_bt}-usr.bin/mkcsmapper: ${_bt}-usr.bin/yacc ${_bt_lex_depend}
.endif
.if ${MK_KERBEROS} != "no"
_kerberos5_bootstrap_tools= \
kerberos5/tools/make-roken \
kerberos5/lib/libroken \
kerberos5/lib/libvers \
kerberos5/tools/asn1_compile \
kerberos5/tools/slc \
usr.bin/compile_et
.ORDER: ${_kerberos5_bootstrap_tools:C/^/${_bt}-/g}
.for _tool in ${_kerberos5_bootstrap_tools}
${_bt}-${_tool}: ${_bt}-usr.bin/yacc ${_bt_lex_depend}
.endfor
.endif
${_bt}-usr.bin/mandoc: ${_bt}-lib/libopenbsd
# The tools listed in _basic_bootstrap_tools will generally not be
# bootstrapped unless BOOTSTRAP_ALL_TOOL is set. However, when building on a
# Linux or MacOS host the host versions are incompatible so we need to build
# them from the source tree. Usually the link name will be the same as the subdir,
# but some directories such as grep or test install multiple binaries. In that
# case we use the _basic_bootstrap_tools_multilink variable which is a list of
# subdirectory and comma-separated list of files.
_basic_bootstrap_tools_multilink=usr.bin/grep grep,egrep,fgrep
_basic_bootstrap_tools_multilink+=bin/test test,[
# bootstrap tools needed by buildworld:
_basic_bootstrap_tools+=usr.bin/cut bin/expr usr.bin/gencat usr.bin/join \
usr.bin/mktemp bin/realpath bin/rmdir usr.bin/sed usr.bin/sort \
usr.bin/truncate usr.bin/tsort
# Some build scripts use nawk instead of awk (this happens at least in
# cddl/contrib/opensolaris/lib/libdtrace/common/mknames.sh) so we need both awk
# and nawk in ${WORLDTMP}/legacy/bin.
_basic_bootstrap_tools_multilink+=usr.bin/awk awk,nawk
# file2c is required for building usr.sbin/config:
_basic_bootstrap_tools+=usr.bin/file2c
# uuencode/uudecode required for share/tabset
_basic_bootstrap_tools_multilink+=usr.bin/bintrans uuencode,uudecode
# xargs is required by mkioctls
_basic_bootstrap_tools+=usr.bin/xargs
# cap_mkdb is required for share/termcap:
_basic_bootstrap_tools+=usr.bin/cap_mkdb
# services_mkdb/pwd_mkdb are required for installworld:
_basic_bootstrap_tools+=usr.sbin/services_mkdb usr.sbin/pwd_mkdb
# ldd is required for installcheck (TODO: just always use /usr/bin/ldd instead?)
.if !defined(CROSSBUILD_HOST)
# ldd is only needed for updating the running system so we don't need to
# bootstrap ldd on non-FreeBSD systems
_basic_bootstrap_tools+=usr.bin/ldd
.endif
# sysctl/chflags are required for installkernel:
.if !defined(CROSSBUILD_HOST)
_basic_bootstrap_tools+=bin/chflags
# Note: sysctl does not bootstrap on FreeBSD < 13 anymore, but that doesn't
# matter since we don't need any of the new features for the build.
_bootstrap_tools_links+=sysctl
.else
# When building on non-FreeBSD, install a fake chflags instead since the
# version from the source tree cannot work. We also don't need sysctl since we
# are install with -DNO_ROOT.
_other_bootstrap_tools+=tools/build/cross-build/fake_chflags
.endif
# mkfifo is used by sys/conf/newvers.sh
_basic_bootstrap_tools+=usr.bin/mkfifo
# jot is needed for the mkimg tests
_basic_bootstrap_tools+=usr.bin/jot
.if ${MK_BOOT} != "no"
# md5 is used by boot/beri (and possibly others)
_basic_bootstrap_tools+=sbin/md5
.endif
.if ${MK_ZONEINFO} != "no"
_basic_bootstrap_tools+=usr.sbin/zic usr.sbin/tzsetup
.endif
.if defined(BOOTSTRAP_ALL_TOOLS)
_other_bootstrap_tools+=${_basic_bootstrap_tools}
.for _subdir _links in ${_basic_bootstrap_tools_multilink}
_other_bootstrap_tools+=${_subdir}
.endfor
${_bt}-usr.bin/awk: ${_bt_lex_depend} ${_bt}-usr.bin/yacc
${_bt}-bin/expr: ${_bt_lex_depend} ${_bt}-usr.bin/yacc
# If we are bootstrapping file2c, we have to build it before config:
${_bt}-usr.sbin/config: ${_bt}-usr.bin/file2c ${_bt_lex_depend}
# Note: no symlink to make/bmake in the !BOOTSTRAP_ALL_TOOLS case here since
# the links to make/bmake make links will have already have been created in the
# `make legacy` step. Not adding a link to make is important on non-FreeBSD
# since "make" will usually point to GNU make there.
_other_bootstrap_tools+=usr.bin/bmake
# Avoid dependency on host bz2 headers:
_other_bootstrap_tools+=lib/libbz2
${_bt}-usr.bin/grep: ${_bt}-lib/libbz2
# libdwarf depends on libz
_other_bootstrap_tools+=lib/libz
${_bt}-lib/libdwarf: ${_bt}-lib/libz
# libroken depends on libcrypt
_other_bootstrap_tools+=lib/libcrypt
${_bt}-lib/libroken: ${_bt}-lib/libcrypt
.else
# All tools in _basic_bootstrap_tools have the same name as the subdirectory
# so we can use :T to get the name of the symlinks that we need to create.
_bootstrap_tools_links+=${_basic_bootstrap_tools:T}
.for _subdir _links in ${_basic_bootstrap_tools_multilink}
_bootstrap_tools_links+=${_links:S/,/ /g}
.endfor
.endif # defined(BOOTSTRAP_ALL_TOOLS)
# Link the tools that we need for building but don't need to bootstrap because
# the host version is known to be compatible into ${WORLDTMP}/legacy
# We do this before building any of the bootstrap tools in case they depend on
# the presence of any of the links (e.g. as m4/lex/awk)
${_bt}-links: .PHONY
.for _tool in ${_bootstrap_tools_links}
${_bt}-link-${_tool}: .PHONY
@rm -f "${WORLDTMP}/legacy/bin/${_tool}"; \
source_path=`which ${_tool}`; \
if [ ! -e "$${source_path}" ] ; then \
echo "Cannot find host tool '${_tool}'"; false; \
fi; \
cp -pf "$${source_path}" "${WORLDTMP}/legacy/bin/${_tool}"
${_bt}-links: ${_bt}-link-${_tool}
.endfor
bootstrap-tools: ${_bt}-links .PHONY
# Please document (add comment) why something is in 'bootstrap-tools'.
# Try to bound the building of the bootstrap-tool to just the
# FreeBSD versions that need the tool built at this stage of the build.
.for _tool in \
${_clang_tblgen} \
${_kerberos5_bootstrap_tools} \
${_strfile} \
usr.bin/dtc \
${_cat} \
${_kbdcontrol} \
${_elftoolchain_libs} \
lib/libopenbsd \
usr.bin/mandoc \
usr.bin/rpcgen \
${_yacc} \
${_m4} \
${_lex} \
${_other_bootstrap_tools} \
usr.bin/xinstall \
${_gensnmptree} \
${_config} \
${_flua} \
${_crunchide} \
${_crunchgen} \
${_mkimg} \
${_nmtree} \
${_vtfontcvt} \
${_localedef} \
${_mkcsmapper} \
${_mkesdb} \
${LOCAL_BSTOOL_DIRS}
${_bt}-${_tool}: ${_bt}-links .PHONY .MAKE
${_+_}@${ECHODIR} "===> ${_tool} (obj,all,install)"; \
cd ${.CURDIR}/${_tool}; \
if [ -z "${NO_OBJWALK}" ]; then ${MAKE} DIRPRFX=${_tool}/ obj; fi; \
if [ "${_tool}" = "usr.bin/lex" ]; then \
${MAKE} DIRPRFX=${_tool}/ bootstrap; \
fi; \
${MAKE} DIRPRFX=${_tool}/ all; \
${MAKE} DIRPRFX=${_tool}/ DESTDIR=${WORLDTMP}/legacy install
bootstrap-tools: ${_bt}-${_tool}
.endfor
.if target(${_bt}-lib/libmd)
# If we are bootstrapping libmd (e.g. when building on macOS/Linux) add the
# necessary dependencies:
${_bt}-usr.bin/sort: ${_bt}-lib/libmd
${_bt}-usr.bin/xinstall: ${_bt}-lib/libmd
${_bt}-sbin/md5: ${_bt}-lib/libmd
.endif
#
# build-tools: Build special purpose build tools
#
.if !defined(NO_SHARE) && ${MK_SYSCONS} != "no"
_share= share/syscons/scrnmaps
.endif
.if ${MK_RESCUE} != "no"
# rescue includes programs that have build-tools targets
_rescue=rescue/rescue
.endif
.if ${MK_TCSH} != "no"
_tcsh=bin/csh
.endif
.if ${MK_FILE} != "no"
_libmagic=lib/libmagic
.endif
.if ${MK_PMC} != "no"
_jevents=lib/libpmc/pmu-events
.endif
# kernel-toolchain skips _cleanobj, so handle cleaning up previous
# build-tools directories if needed.
.if ${MK_CLEAN} == "yes" && make(kernel-toolchain)
_bt_clean= ${CLEANDIR}
.endif
.for _tool in \
${_tcsh} \
bin/sh \
${LOCAL_TOOL_DIRS} \
${_jevents} \
lib/ncurses/tinfo \
${_rescue} \
${_share} \
usr.bin/awk \
${_libmagic} \
usr.bin/vi/catalog
build-tools_${_tool}: .PHONY
${_+_}@${ECHODIR} "===> ${_tool} (${_bt_clean:D${_bt_clean},}obj,build-tools)"; \
cd ${.CURDIR}/${_tool}; \
if [ -n "${_bt_clean}" ]; then ${MAKE} DIRPRFX=${_tool}/ ${_bt_clean}; fi; \
if [ -z "${NO_OBJWALK}" ]; then ${MAKE} DIRPRFX=${_tool}/ obj; fi; \
${MAKE} DIRPRFX=${_tool}/ build-tools
build-tools: build-tools_${_tool}
.endfor
#
# kernel-tools: Build kernel-building tools
#
kernel-tools: .PHONY
mkdir -p ${WORLDTMP}/usr
${WORLDTMP_MTREE} -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
-p ${WORLDTMP}/usr >/dev/null
#
# cross-tools: All the tools needed to build the rest of the system after
# we get done with the earlier stages. It is the last set of tools needed
# to begin building the target binaries.
#
.if ${TARGET_ARCH} != ${MACHINE_ARCH} || ${BUILD_WITH_STRICT_TMPPATH} != 0
.if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "i386"
_btxld= usr.sbin/btxld
.endif
.endif
# Rebuild ctfconvert and ctfmerge to avoid difficult-to-diagnose failures
# resulting from missing bug fixes or ELF Toolchain updates.
.if ${MK_CDDL} != "no"
_dtrace_tools= cddl/lib/libctf cddl/lib/libspl cddl/usr.bin/ctfconvert \
cddl/usr.bin/ctfmerge
.endif
# If we're given an XAS, don't build binutils.
.if ${XAS:M/*} == ""
.if ${MK_ELFTOOLCHAIN_BOOTSTRAP} != "no"
_elftctools= lib/libelftc \
lib/libpe \
usr.bin/elfctl \
usr.bin/elfdump \
usr.bin/objcopy \
usr.bin/nm \
usr.bin/size \
usr.bin/strings
# These are not required by the build, but can be useful for developers who
# cross-build on a FreeBSD 10 host:
_elftctools+= usr.bin/addr2line
.endif
.elif ${TARGET_ARCH} != ${MACHINE_ARCH} && ${MK_ELFTOOLCHAIN_BOOTSTRAP} != "no"
# If cross-building with an external binutils we still need to build strip for
# the target (for at least crunchide).
_elftctools= lib/libelftc \
lib/libpe \
usr.bin/elfctl \
usr.bin/elfdump \
usr.bin/objcopy
.endif
.if ${MK_CLANG_BOOTSTRAP} != "no"
_clang= usr.bin/clang
.endif
.if ${MK_LLD_BOOTSTRAP} != "no"
_lld= usr.bin/clang/lld
.endif
.if ${MK_CLANG_BOOTSTRAP} != "no" || ${MK_LLD_BOOTSTRAP} != "no"
_clang_libs= lib/clang
.endif
.if ${MK_USB} != "no"
_usb_tools= stand/usb/tools
.endif
.if ${BUILD_WITH_STRICT_TMPPATH} != 0 || defined(BOOTSTRAP_ALL_TOOLS)
_ar=usr.bin/ar
.endif
cross-tools: .MAKE .PHONY
.for _tool in \
${LOCAL_XTOOL_DIRS} \
${_ar} \
${_clang_libs} \
${_clang} \
${_lld} \
${_elftctools} \
${_dtrace_tools} \
${_btxld} \
${_usb_tools}
${_+_}@${ECHODIR} "===> ${_tool} (obj,all,install)"; \
cd ${.CURDIR}/${_tool}; \
if [ -z "${NO_OBJWALK}" ]; then ${MAKE} DIRPRFX=${_tool}/ obj; fi; \
${MAKE} DIRPRFX=${_tool}/ all; \
${MAKE} DIRPRFX=${_tool}/ DESTDIR=${WORLDTMP} install
.endfor
#
# native-xtools is the current target for qemu-user cross builds of ports
# via poudriere and the imgact_binmisc kernel module.
# This target merely builds a toolchan/sysroot, then builds the tools it wants
# with the options it wants in a special MAKEOBJDIRPREFIX, using the toolchain
# already built. It then installs the static tools to NXBDESTDIR for Poudriere
# to pickup.
#
NXBOBJROOT= ${OBJROOT}${MACHINE}.${MACHINE_ARCH}/nxb/
NXBOBJTOP= ${NXBOBJROOT}${NXB_TARGET}.${NXB_TARGET_ARCH}
NXTP?= /nxb-bin
.if ${NXTP:N/*}
.error NXTP variable should be an absolute path
.endif
NXBDESTDIR?= ${DESTDIR}${NXTP}
# This is the list of tools to be built/installed as static and where
# appropriate to build for the given TARGET.TARGET_ARCH.
NXBDIRS+= \
bin/cat \
bin/chmod \
bin/cp \
${_tcsh} \
bin/echo \
bin/expr \
bin/hostname \
bin/ln \
bin/ls \
bin/mkdir \
bin/mv \
bin/ps \
bin/realpath \
bin/rm \
bin/rmdir \
bin/sh \
bin/sleep \
sbin/md5 \
sbin/sysctl \
usr.bin/addr2line \
usr.bin/ar \
usr.bin/awk \
usr.bin/basename \
usr.bin/bmake \
usr.bin/bzip2 \
usr.bin/cmp \
usr.bin/diff \
usr.bin/dirname \
usr.bin/objcopy \
usr.bin/env \
usr.bin/fetch \
usr.bin/find \
usr.bin/grep \
usr.bin/gzip \
usr.bin/head \
usr.bin/id \
usr.bin/lex \
usr.bin/limits \
usr.bin/mandoc \
usr.bin/mktemp \
usr.bin/mt \
usr.bin/nm \
usr.bin/patch \
usr.bin/readelf \
usr.bin/sed \
usr.bin/size \
usr.bin/sort \
usr.bin/strings \
usr.bin/tar \
usr.bin/touch \
usr.bin/tr \
usr.bin/true \
usr.bin/uniq \
usr.bin/unzip \
usr.bin/wc \
usr.bin/xargs \
usr.bin/xinstall \
usr.bin/xz \
usr.bin/yacc \
usr.sbin/chown
SUBDIR_DEPEND_usr.bin/clang= lib/clang
.if ${MK_CLANG} != "no"
NXBDIRS+= lib/clang
NXBDIRS+= usr.bin/clang
.endif
# XXX: native-xtools passes along ${NXBDIRS} in SUBDIR_OVERRIDE that needs
# to be evaluated after NXBDIRS is set.
.if make(install) && !empty(SUBDIR_OVERRIDE)
SUBDIR= ${SUBDIR_OVERRIDE}
.endif
NXBMAKEARGS+= \
OBJTOP=${NXBOBJTOP:Q} \
OBJROOT=${NXBOBJROOT:Q} \
-DNO_SHARED \
-DNO_CPU_CFLAGS \
-DNO_PIC \
MK_CASPER=no \
MK_CLANG_EXTRAS=no \
MK_CLANG_FORMAT=no \
MK_CLANG_FULL=no \
MK_CTF=no \
MK_DEBUG_FILES=no \
MK_HTML=no \
MK_LLDB=no \
MK_MAN=no \
MK_MAN_UTILS=yes \
MK_OFED=no \
MK_OPENSSH=no \
MK_PROFILE=no \
MK_RETPOLINE=no \
MK_SENDMAIL=no \
MK_SSP=no \
MK_TESTS=no \
MK_WERROR=no \
MK_ZFS=no
NXBMAKEENV+= \
MAKEOBJDIRPREFIX=
# This should match all of the knobs in lib/Makefile that it takes to avoid
# descending into lib/clang!
NXBTNOTOOLS= MK_CLANG=no MK_LLD=no MK_LLDB=no MK_LLVM_BINUTILS=no
.if make(native-xtools*) && \
(!defined(NXB_TARGET) || !defined(NXB_TARGET_ARCH))
.error Missing NXB_TARGET / NXB_TARGET_ARCH
.endif
# For 'toolchain' we want to produce native binaries that themselves generate
# native binaries.
NXBTMAKE= ${NXBMAKEENV} ${MAKE} ${NXBMAKEARGS:N-DNO_PIC:N-DNO_SHARED} \
TARGET=${MACHINE} TARGET_ARCH=${MACHINE_ARCH}
# For 'everything' we want to produce native binaries (hence -target to
# be MACHINE) that themselves generate TARGET.TARGET_ARCH binaries.
# TARGET/TARGET_ARCH are still passed along from user.
#
# Use the toolchain we create as an external toolchain.
.if ${USING_SYSTEM_COMPILER} == "yes" || ${XCC:N${CCACHE_BIN}:M/*}
NXBMAKE+= XCC="${XCC}" \
XCXX="${XCXX}" \
XCPP="${XCPP}"
.else
NXBMAKE+= XCC="${NXBOBJTOP}/tmp/usr/bin/cc" \
XCXX="${NXBOBJTOP}/tmp/usr/bin/c++" \
XCPP="${NXBOBJTOP}/tmp/usr/bin/cpp"
.endif
NXBMAKE+= ${NXBMAKEENV} ${MAKE} -f Makefile.inc1 ${NXBMAKEARGS} \
MACHINE=${MACHINE} MACHINE_ARCH=${MACHINE_ARCH} \
TARGET=${NXB_TARGET} TARGET_ARCH=${NXB_TARGET_ARCH} \
TARGET_TRIPLE=${MACHINE_TRIPLE:Q}
# NXBDIRS is improperly based on MACHINE rather than NXB_TARGET. Need to
# invoke a sub-make to reevaluate MK_CLANG, etc, for NXBDIRS.
NXBMAKE+= SUBDIR_OVERRIDE='$${NXBDIRS:M*}'
# Need to avoid the -isystem logic when using clang as an external toolchain
# even if the TARGET being built for wants GCC.
NXBMAKE+= WANT_COMPILER_TYPE='$${X_COMPILER_TYPE}'
native-xtools: .PHONY
${_+_}cd ${.CURDIR}; ${NXBTMAKE} _cleanobj
# Build the bootstrap/host/cross tools that produce native binaries
${_+_}cd ${.CURDIR}; ${NXBTMAKE} kernel-toolchain
# Populate includes/libraries sysroot that produce native binaries.
# This is split out from 'toolchain' above mostly so that target LLVM
# libraries have a proper LLVM_DEFAULT_TARGET_TRIPLE without
# polluting the cross-compiler build. The LLVM libs are skipped
# here to avoid the problem but are kept in 'toolchain' so that
# needed build tools are built.
${_+_}cd ${.CURDIR}; ${NXBTMAKE} _includes ${NXBTNOTOOLS}
${_+_}cd ${.CURDIR}; ${NXBTMAKE} _libraries ${NXBTNOTOOLS}
.if !defined(NO_OBJWALK)
${_+_}cd ${.CURDIR}; ${NXBMAKE} _obj
.endif
${_+_}cd ${.CURDIR}; ${NXBMAKE} everything
@echo ">> native-xtools done. Use 'make native-xtools-install' to install to a given DESTDIR"
native-xtools-install: .PHONY
mkdir -p ${NXBDESTDIR}/bin ${NXBDESTDIR}/sbin ${NXBDESTDIR}/usr
${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
-p ${NXBDESTDIR}/usr >/dev/null
${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.include.dist \
-p ${NXBDESTDIR}/usr/include >/dev/null
${_+_}cd ${.CURDIR}; ${NXBMAKE} \
DESTDIR=${NXBDESTDIR} \
-DNO_ROOT \
install
#
# hierarchy - ensure that all the needed directories are present
#
hierarchy hier: .MAKE .PHONY
${_+_}cd ${.CURDIR}/etc; ${HMAKE} distrib-dirs
#
# libraries - build all libraries, and install them under ${DESTDIR}.
#
# The list of libraries with dependents (${_prebuild_libs}) and their
# interdependencies (__L) are built automatically by the
# ${.CURDIR}/tools/make_libdeps.sh script.
#
libraries: .MAKE .PHONY
${_+_}cd ${.CURDIR}; \
${MAKE} -f Makefile.inc1 _prereq_libs; \
${MAKE} -f Makefile.inc1 _startup_libs; \
${MAKE} -f Makefile.inc1 _prebuild_libs; \
${MAKE} -f Makefile.inc1 _generic_libs
#
# static libgcc.a prerequisite for shared libc
#
_prereq_libs= lib/libcompiler_rt
.if ${MK_SSP} != "no"
_prereq_libs+= lib/libssp_nonshared
.endif
.if ${MK_ASAN} != "no"
_prereq_libs+= lib/libclang_rt/asan
_prereq_libs+= lib/libclang_rt/asan-preinit
_prereq_libs+= lib/libclang_rt/asan_cxx
.endif
.if ${MK_UBSAN} != "no"
_prereq_libs+= lib/libclang_rt/ubsan_minimal
_prereq_libs+= lib/libclang_rt/ubsan_standalone
_prereq_libs+= lib/libclang_rt/ubsan_standalone_cxx
.endif
# These dependencies are not automatically generated:
#
# lib/csu and lib/libc must be built before
# all shared libraries for ELF.
#
_startup_libs= lib/csu
_startup_libs+= lib/libc
_startup_libs+= lib/libc_nonshared
.if ${MK_CXX} != "no"
_startup_libs+= lib/libcxxrt
.endif
_prereq_libs+= lib/libgcc_eh lib/libgcc_s
_startup_libs+= lib/libgcc_eh lib/libgcc_s
lib/libgcc_s__L: lib/libc__L
lib/libgcc_s__L: lib/libc_nonshared__L
.if ${MK_CXX} != "no"
lib/libcxxrt__L: lib/libgcc_s__L
.endif
_prebuild_libs= ${_kerberos5_lib_libasn1} \
${_kerberos5_lib_libhdb} \
${_kerberos5_lib_libheimbase} \
${_kerberos5_lib_libheimntlm} \
${_libsqlite3} \
${_kerberos5_lib_libheimipcc} \
${_kerberos5_lib_libhx509} ${_kerberos5_lib_libkrb5} \
${_kerberos5_lib_libroken} \
${_kerberos5_lib_libwind} \
lib/libbz2 ${_libcom_err} lib/libcrypt \
lib/libelf lib/libexpat \
lib/libfigpar \
${_lib_libgssapi} \
lib/libjail \
lib/libkiconv lib/libkvm lib/liblzma lib/libmd lib/libnv \
lib/libzstd \
${_lib_casper} \
lib/ncurses/tinfo \
lib/ncurses/ncurses \
lib/ncurses/form \
lib/libopie lib/libpam/libpam lib/libthr \
${_lib_libradius} lib/libsbuf lib/libtacplus \
lib/libgeom \
${_cddl_lib_libumem} ${_cddl_lib_libnvpair} \
${_cddl_lib_libuutil} \
${_cddl_lib_libavl} \
${_cddl_lib_libicp} \
${_cddl_lib_libicp_rescue} \
${_cddl_lib_libspl} \
${_cddl_lib_libtpool} \
${_cddl_lib_libzfs_core} ${_cddl_lib_libzfs} \
${_cddl_lib_libzutil} \
${_cddl_lib_libctf} ${_cddl_lib_libzfsbootenv} \
lib/libufs \
lib/libutil lib/libpjdlog ${_lib_libypclnt} lib/libz lib/msun \
${_secure_lib_libcrypto} ${_secure_lib_libssl} \
${_lib_libldns} ${_secure_lib_libssh}
.if ${MK_DIALOG} != "no"
_prebuild_libs+= gnu/lib/libdialog
gnu/lib/libdialog__L: lib/msun__L lib/ncurses/tinfo__L lib/ncurses/ncurses__L
.endif
.if ${MK_GOOGLETEST} != "no"
_prebuild_libs+= lib/libregex
.endif
.if ${MK_CXX} != "no"
_prebuild_libs+= lib/libc++
.endif
lib/libgeom__L: lib/libexpat__L lib/libsbuf__L
lib/libkvm__L: lib/libelf__L
.if ${MK_RADIUS_SUPPORT} != "no"
_lib_libradius= lib/libradius
.endif
lib/ncurses/ncurses__L: lib/ncurses/tinfo__L
lib/ncurses/form__L: lib/ncurses/ncurses__L
.if ${MK_OFED} != "no"
_prebuild_libs+= \
lib/ofed/libibverbs \
lib/ofed/libibmad \
lib/ofed/libibumad \
lib/ofed/complib \
lib/ofed/libmlx5
lib/ofed/libibmad__L: lib/ofed/libibumad__L
lib/ofed/complib__L: lib/libthr__L
lib/ofed/libmlx5__L: lib/ofed/libibverbs__L lib/libthr__L
.endif
.if ${MK_CASPER} != "no"
_lib_casper= lib/libcasper
.endif
lib/libpjdlog__L: lib/libutil__L
lib/libcasper__L: lib/libnv__L
lib/liblzma__L: lib/libmd__L lib/libthr__L
lib/libzstd__L: lib/libthr__L
_generic_libs= ${_cddl_lib} gnu/lib ${_kerberos5_lib} lib ${_secure_lib}
.if ${MK_IPFILTER} != "no"
_generic_libs+= sbin/ipf/libipf
.endif
.for _DIR in ${LOCAL_LIB_DIRS}
.if ${_DIR} == ".WAIT" || (empty(_generic_libs:M${_DIR}) && exists(${.CURDIR}/${_DIR}/Makefile))
_generic_libs+= ${_DIR}
.endif
.endfor
lib/libopie__L lib/libtacplus__L: lib/libmd__L
.if ${MK_CDDL} != "no"
_cddl_lib_libumem= cddl/lib/libumem
_cddl_lib_libnvpair= cddl/lib/libnvpair
_cddl_lib_libavl= cddl/lib/libavl
_cddl_lib_libuutil= cddl/lib/libuutil
_cddl_lib_libspl= cddl/lib/libspl
cddl/lib/libavl__L: cddl/lib/libspl__L
cddl/lib/libnvpair__L: cddl/lib/libspl__L
cddl/lib/libuutil__L: cddl/lib/libavl__L cddl/lib/libspl__L
.if ${MK_ZFS} != "no"
_cddl_lib_libicp= cddl/lib/libicp
_cddl_lib_libicp_rescue= cddl/lib/libicp_rescue
_cddl_lib_libtpool= cddl/lib/libtpool
_cddl_lib_libzutil= cddl/lib/libzutil
_cddl_lib_libzfs_core= cddl/lib/libzfs_core
_cddl_lib_libzfs= cddl/lib/libzfs
_cddl_lib_libzfsbootenv= cddl/lib/libzfsbootenv
cddl/lib/libtpool__L: cddl/lib/libspl__L
cddl/lib/libzutil__L: cddl/lib/libavl__L lib/libgeom__L lib/msun__L cddl/lib/libtpool__L
cddl/lib/libzfs_core__L: cddl/lib/libnvpair__L cddl/lib/libspl__L cddl/lib/libzutil__L
cddl/lib/libzfs__L: cddl/lib/libzfs_core__L lib/msun__L lib/libutil__L
cddl/lib/libzfs__L: lib/libthr__L lib/libmd__L lib/libz__L cddl/lib/libumem__L
cddl/lib/libzfs__L: cddl/lib/libuutil__L cddl/lib/libavl__L lib/libgeom__L
cddl/lib/libzfs__L: cddl/lib/libnvpair__L cddl/lib/libzutil__L
cddl/lib/libzfs__L: secure/lib/libcrypto__L
cddl/lib/libzfsbootenv__L: cddl/lib/libzfs__L
lib/libbe__L: cddl/lib/libzfs__L cddl/lib/libzfsbootenv__L
.endif
_cddl_lib_libctf= cddl/lib/libctf
_cddl_lib= cddl/lib
cddl/lib/libctf__L: lib/libz__L cddl/lib/libspl__L
.endif
# cddl/lib/libdtrace requires lib/libproc and lib/librtld_db
_prebuild_libs+= lib/libprocstat lib/libproc lib/librtld_db
lib/libprocstat__L: lib/libelf__L lib/libkvm__L lib/libutil__L
lib/libproc__L: lib/libprocstat__L
lib/librtld_db__L: lib/libprocstat__L
.if ${MK_CRYPT} != "no"
.if ${MK_OPENSSL} != "no"
_secure_lib_libcrypto= secure/lib/libcrypto
_secure_lib_libssl= secure/lib/libssl
lib/libradius__L secure/lib/libssl__L: secure/lib/libcrypto__L
secure/lib/libcrypto__L: lib/libthr__L
.if ${MK_LDNS} != "no"
_lib_libldns= lib/libldns
lib/libldns__L: secure/lib/libssl__L
.endif
.if ${MK_OPENSSH} != "no"
_secure_lib_libssh= secure/lib/libssh
secure/lib/libssh__L: lib/libz__L secure/lib/libcrypto__L lib/libcrypt__L
.if ${MK_LDNS} != "no"
secure/lib/libssh__L: lib/libldns__L
.endif
.if ${MK_GSSAPI} != "no" && ${MK_KERBEROS_SUPPORT} != "no"
secure/lib/libssh__L: lib/libgssapi__L kerberos5/lib/libkrb5__L \
kerberos5/lib/libhx509__L kerberos5/lib/libasn1__L lib/libcom_err__L \
lib/libmd__L kerberos5/lib/libroken__L
.endif
.endif
.endif
_secure_lib= secure/lib
.endif
.if ${MK_KERBEROS} != "no"
kerberos5/lib/libasn1__L: lib/libcom_err__L kerberos5/lib/libroken__L
kerberos5/lib/libhdb__L: kerberos5/lib/libasn1__L lib/libcom_err__L \
kerberos5/lib/libkrb5__L kerberos5/lib/libroken__L \
kerberos5/lib/libwind__L lib/libsqlite3__L
kerberos5/lib/libheimntlm__L: secure/lib/libcrypto__L kerberos5/lib/libkrb5__L \
kerberos5/lib/libroken__L lib/libcom_err__L
kerberos5/lib/libhx509__L: kerberos5/lib/libasn1__L lib/libcom_err__L \
secure/lib/libcrypto__L kerberos5/lib/libroken__L kerberos5/lib/libwind__L
kerberos5/lib/libkrb5__L: kerberos5/lib/libasn1__L lib/libcom_err__L \
lib/libcrypt__L secure/lib/libcrypto__L kerberos5/lib/libhx509__L \
kerberos5/lib/libroken__L kerberos5/lib/libwind__L \
kerberos5/lib/libheimbase__L kerberos5/lib/libheimipcc__L
kerberos5/lib/libroken__L: lib/libcrypt__L
kerberos5/lib/libwind__L: kerberos5/lib/libroken__L lib/libcom_err__L
kerberos5/lib/libheimbase__L: lib/libthr__L
kerberos5/lib/libheimipcc__L: kerberos5/lib/libroken__L kerberos5/lib/libheimbase__L lib/libthr__L
.endif
lib/libsqlite3__L: lib/libthr__L
.if ${MK_GSSAPI} != "no"
_lib_libgssapi= lib/libgssapi
.endif
.if ${MK_KERBEROS} != "no"
_kerberos5_lib= kerberos5/lib
_kerberos5_lib_libasn1= kerberos5/lib/libasn1
_kerberos5_lib_libhdb= kerberos5/lib/libhdb
_kerberos5_lib_libheimbase= kerberos5/lib/libheimbase
_kerberos5_lib_libkrb5= kerberos5/lib/libkrb5
_kerberos5_lib_libhx509= kerberos5/lib/libhx509
_kerberos5_lib_libroken= kerberos5/lib/libroken
_kerberos5_lib_libheimntlm= kerberos5/lib/libheimntlm
_libsqlite3= lib/libsqlite3
_kerberos5_lib_libheimipcc= kerberos5/lib/libheimipcc
_kerberos5_lib_libwind= kerberos5/lib/libwind
_libcom_err= lib/libcom_err
.endif
.if ${MK_NIS} != "no"
_lib_libypclnt= lib/libypclnt
.endif
.if ${MK_OPENSSL} == "no"
lib/libradius__L: lib/libmd__L
.endif
lib/libproc__L: \
${_cddl_lib_libctf:D${_cddl_lib_libctf}__L} lib/libelf__L lib/librtld_db__L lib/libutil__L
.if ${MK_CXX} != "no"
lib/libproc__L: lib/libcxxrt__L
.endif
.for _lib in ${_prereq_libs}
${_lib}__PL: .PHONY .MAKE
.if !defined(_MKSHOWCONFIG) && exists(${.CURDIR}/${_lib})
${_+_}@${ECHODIR} "===> ${_lib} (obj,all,install)"; \
cd ${.CURDIR}/${_lib}; \
if [ -z "${NO_OBJWALK}" ]; then ${MAKE} MK_TESTS=no DIRPRFX=${_lib}/ obj; fi; \
${MAKE} MK_TESTS=no MK_PROFILE=no -DNO_PIC \
DIRPRFX=${_lib}/ all; \
${MAKE} MK_TESTS=no MK_PROFILE=no -DNO_PIC \
DIRPRFX=${_lib}/ install
.endif
.endfor
.for _lib in ${_startup_libs} ${_prebuild_libs} ${_generic_libs}
${_lib}__L: .PHONY .MAKE
.if !defined(_MKSHOWCONFIG) && exists(${.CURDIR}/${_lib})
${_+_}@${ECHODIR} "===> ${_lib} (obj,all,install)"; \
cd ${.CURDIR}/${_lib}; \
if [ -z "${NO_OBJWALK}" ]; then ${MAKE} MK_TESTS=no DIRPRFX=${_lib}/ obj; fi; \
${MAKE} MK_TESTS=no DIRPRFX=${_lib}/ all; \
${MAKE} MK_TESTS=no DIRPRFX=${_lib}/ install
.endif
.endfor
_prereq_libs: ${_prereq_libs:S/$/__PL/}
_startup_libs: ${_startup_libs:S/$/__L/}
_prebuild_libs: ${_prebuild_libs:S/$/__L/}
_generic_libs: ${_generic_libs:S/$/__L/}
# Enable SUBDIR_PARALLEL when not calling 'make all', unless called from
# 'everything' with _PARALLEL_SUBDIR_OK set. This is because it is unlikely
# that running 'make all' from the top-level, especially with a SUBDIR_OVERRIDE
# or LOCAL_DIRS set, will have a reliable build if SUBDIRs are built in
# parallel. This is safe for the world stage of buildworld though since it has
# already built libraries in a proper order and installed includes into
# WORLDTMP. Special handling is done for SUBDIR ordering for 'install*' to
# avoid trashing a system if it crashes mid-install.
.if !make(all) || defined(_PARALLEL_SUBDIR_OK)
SUBDIR_PARALLEL=
.endif
.include <bsd.subdir.mk>
.if make(check-old) || make(check-old-dirs) || \
make(check-old-files) || make(check-old-libs) || \
make(delete-old) || make(delete-old-dirs) || \
make(delete-old-files) || make(delete-old-libs) || \
make(list-old-dirs) || make(list-old-files) || make(list-old-libs)
#
# check for / delete old files section
#
.include "ObsoleteFiles.inc"
OLD_LIBS_MESSAGE="Please be sure no application still uses those libraries, \
else you can not start such an application. Consult UPDATING for more \
information regarding how to cope with the removal/revision bump of a \
specific library."
.if !defined(BATCH_DELETE_OLD_FILES)
RM_I=-i
.else
RM_I=-v
.endif
list-old-files: .PHONY
@cd ${.CURDIR}; \
${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
-V OLD_FILES -V "OLD_FILES:Musr/share/*.gz:R" \
-V "OLD_FILES:Mlib/*.so.*:S,^lib,usr/lib32," \
-V "OLD_FILES:Musr/lib/*:S,^usr/lib,usr/lib32," | \
sed -E 's/[[:space:]]+/\n/g' | sort
delete-old-files: .PHONY
@echo ">>> Removing old files (only deletes safe to delete libs)"
# Ask for every old file if the user really wants to remove it.
# It's annoying, but better safe than sorry.
# NB: We cannot pass the list of OLD_FILES as a parameter because the
# argument list will get too long. Using .for/.endfor make "loops" will make
# the Makefile parser segfault.
@exec 3<&0; \
cd ${.CURDIR}; \
${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} list-old-files | \
while read file; do \
if [ -f "${DESTDIR}/$${file}" -o -L "${DESTDIR}/$${file}" ]; then \
chflags noschg "${DESTDIR}/$${file}" 2>/dev/null || true; \
rm ${RM_I} "${DESTDIR}/$${file}" <&3; \
fi; \
for ext in debug symbols; do \
if ! [ -e "${DESTDIR}/$${file}" ] && [ -f \
"${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" ]; then \
rm ${RM_I} "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" \
<&3; \
fi; \
done; \
done
# Remove catpages without corresponding manpages.
@exec 3<&0; \
find ${DESTDIR}/usr/share/man/cat* ! -type d 2>/dev/null | sort | \
sed -ep -e's:${DESTDIR}/usr/share/man/cat:${DESTDIR}/usr/share/man/man:' | \
while read catpage; do \
read manpage; \
if [ ! -e "$${manpage}" ]; then \
rm ${RM_I} $${catpage} <&3; \
fi; \
done
@echo ">>> Old files removed"
check-old-files: .PHONY
@echo ">>> Checking for old files"
@cd ${.CURDIR}; \
${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} list-old-files | \
while read file; do \
if [ -f "${DESTDIR}/$${file}" -o -L "${DESTDIR}/$${file}" ]; then \
echo "${DESTDIR}/$${file}"; \
fi; \
for ext in debug symbols; do \
if [ -f "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" ]; then \
echo "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}"; \
fi; \
done; \
done
# Check for catpages without corresponding manpages.
@find ${DESTDIR}/usr/share/man/cat* ! -type d 2>/dev/null | \
sed -ep -e's:${DESTDIR}/usr/share/man/cat:${DESTDIR}/usr/share/man/man:' | \
while read catpage; do \
read manpage; \
if [ ! -e "$${manpage}" ]; then \
echo $${catpage}; \
fi; \
done | sort
list-old-libs: .PHONY
@cd ${.CURDIR}; \
${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
-V OLD_LIBS -V MOVED_LIBS -V "OLD_LIBS:Mlib/*:S,^lib,usr/lib32," \
-V "OLD_LIBS:Musr/lib/*:S,^usr/lib,usr/lib32," \
-V "OLD_LIBS:Mlib/casper/*:S,^lib/casper,usr/lib32," | \
sed -E 's/[[:space:]]+/\n/g' | sort
delete-old-libs: .PHONY
@echo ">>> Removing old libraries"
@echo "${OLD_LIBS_MESSAGE}" | fmt
@exec 3<&0; \
cd ${.CURDIR}; \
${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} list-old-libs | \
while read file; do \
if [ -f "${DESTDIR}/$${file}" -o -L "${DESTDIR}/$${file}" ]; then \
chflags noschg "${DESTDIR}/$${file}" 2>/dev/null || true; \
rm ${RM_I} "${DESTDIR}/$${file}" <&3; \
fi; \
for ext in debug symbols; do \
if ! [ -e "${DESTDIR}/$${file}" ] && [ -f \
"${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" ]; then \
rm ${RM_I} "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" \
<&3; \
fi; \
done; \
done
@echo ">>> Old libraries removed"
check-old-libs: .PHONY
@echo ">>> Checking for old libraries"
@cd ${.CURDIR}; \
${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} list-old-libs | \
while read file; do \
if [ -f "${DESTDIR}/$${file}" -o -L "${DESTDIR}/$${file}" ]; then \
echo "${DESTDIR}/$${file}"; \
fi; \
for ext in debug symbols; do \
if [ -f "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" ]; then \
echo "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}"; \
fi; \
done; \
done
list-old-dirs: .PHONY
@cd ${.CURDIR}; \
${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
-V OLD_DIRS | sed -E 's/[[:space:]]+/\n/g' | sort -r
delete-old-dirs: .PHONY
@echo ">>> Removing old directories"
@cd ${.CURDIR}; \
${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} list-old-dirs | \
while read dir; do \
if [ -d "${DESTDIR}/$${dir}" ]; then \
rmdir -v "${DESTDIR}/$${dir}" || true; \
elif [ -L "${DESTDIR}/$${dir}" ]; then \
echo "${DESTDIR}/$${dir} is a link, please remove everything manually."; \
fi; \
if [ -d "${DESTDIR}${DEBUGDIR}/$${dir}" ]; then \
rmdir -v "${DESTDIR}${DEBUGDIR}/$${dir}" || true; \
elif [ -L "${DESTDIR}${DEBUGDIR}/$${dir}" ]; then \
echo "${DESTDIR}${DEBUGDIR}/$${dir} is a link, please remove everything manually."; \
fi; \
done
@echo ">>> Old directories removed"
check-old-dirs: .PHONY
@echo ">>> Checking for old directories"
@cd ${.CURDIR}; \
${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} list-old-dirs | \
while read dir; do \
if [ -d "${DESTDIR}/$${dir}" ]; then \
echo "${DESTDIR}/$${dir}"; \
elif [ -L "${DESTDIR}/$${dir}" ]; then \
echo "${DESTDIR}/$${dir} is a link, please remove everything manually."; \
fi; \
if [ -d "${DESTDIR}${DEBUGDIR}/$${dir}" ]; then \
echo "${DESTDIR}${DEBUGDIR}/$${dir}"; \
elif [ -L "${DESTDIR}${DEBUGDIR}/$${dir}" ]; then \
echo "${DESTDIR}${DEBUGDIR}/$${dir} is a link, please remove everything manually."; \
fi; \
done
delete-old: delete-old-files delete-old-dirs .PHONY
@echo "To remove old libraries run '${MAKE_CMD} delete-old-libs'."
check-old: check-old-files check-old-libs check-old-dirs .PHONY
@echo "To remove old files and directories run '${MAKE_CMD} delete-old'."
@echo "To remove old libraries run '${MAKE_CMD} delete-old-libs'."
.endif
#
# showconfig - show build configuration.
#
showconfig: .PHONY
@(${MAKE} -n -f ${.CURDIR}/sys/conf/kern.opts.mk -V dummy -dg1 UPDATE_DEPENDFILE=no NO_OBJ=yes; \
${MAKE} -n -f ${.CURDIR}/share/mk/src.opts.mk -V dummy -dg1 UPDATE_DEPENDFILE=no NO_OBJ=yes) 2>&1 | grep ^MK_ | sort -u
.if !empty(KRNLOBJDIR) && !empty(KERNCONF)
DTBOUTPUTPATH= ${KRNLOBJDIR}/${KERNCONF}/
.if !defined(FDT_DTS_FILE) || empty(FDT_DTS_FILE)
.if !defined(_MKSHOWCONFIG) && exists(${KERNCONFDIR}/${KERNCONF})
FDT_DTS_FILE!= awk 'BEGIN {FS="="} /^makeoptions[[:space:]]+FDT_DTS_FILE/ {print $$2}' \
'${KERNCONFDIR}/${KERNCONF}' ; echo
.endif
.endif
.endif
.if !defined(DTBOUTPUTPATH) || !exists(${DTBOUTPUTPATH})
DTBOUTPUTPATH= ${.CURDIR}
.endif
#
# Build 'standalone' Device Tree Blob
#
builddtb: .PHONY
@PATH=${TMPPATH} MACHINE=${TARGET} \
sh ${.CURDIR}/sys/tools/fdt/make_dtb.sh ${.CURDIR}/sys \
"${FDT_DTS_FILE}" ${DTBOUTPUTPATH}
###############
# cleanworld
# In the following, the first 'rm' in a series will usually remove all
# files and directories. If it does not, then there are probably some
# files with file flags set, so this unsets them and tries the 'rm' a
# second time. There are situations where this target will be cleaning
# some directories via more than one method, but that duplication is
# needed to correctly handle all the possible situations. Removing all
# files without file flags set in the first 'rm' instance saves time,
# because 'chflags' will need to operate on fewer files afterwards.
#
# It is expected that BW_CANONICALOBJDIR == the CANONICALOBJDIR as would be
# created by bsd.obj.mk, except that we don't want to .include that file
# in this makefile. We don't do a cleandir walk if MK_AUTO_OBJ is yes
# since it is not possible for files to land in the wrong place.
#
.if make(cleanworld)
BW_CANONICALOBJDIR:=${OBJTOP}/
.elif make(cleankernel)
BW_CANONICALOBJDIR:=${KRNLOBJDIR}/${KERNCONF}/
.elif make(cleanuniverse)
BW_CANONICALOBJDIR:=${OBJROOT}
.if ${MK_UNIFIED_OBJDIR} == "no"
.error ${.TARGETS} only supported with WITH_UNIFIED_OBJDIR enabled.
.endif
.endif
cleanworld cleanuniverse cleankernel: .PHONY
.if !empty(BW_CANONICALOBJDIR) && exists(${BW_CANONICALOBJDIR}) && \
${.CURDIR:tA} != ${BW_CANONICALOBJDIR:tA}
-(cd ${BW_CANONICALOBJDIR} && rm -rf *)
-chflags -R 0 ${BW_CANONICALOBJDIR}
-(cd ${BW_CANONICALOBJDIR} && rm -rf *)
.endif
.if make(cleanworld) && ${MK_AUTO_OBJ} == "no" && \
(empty(BW_CANONICALOBJDIR) || ${.CURDIR:tA} == ${BW_CANONICALOBJDIR:tA})
.if ${.CURDIR} == ${.OBJDIR} || ${.CURDIR}/obj == ${.OBJDIR}
# To be safe in this case, fall back to a 'make cleandir'
${_+_}@cd ${.CURDIR}; ${MAKE} cleandir
.endif
.endif
.if ${TARGET} == ${MACHINE} && ${TARGET_ARCH} == ${MACHINE_ARCH}
XDEV_CPUTYPE?=${CPUTYPE}
.else
XDEV_CPUTYPE?=${TARGET_CPUTYPE}
.endif
NOFUN=-DNO_FSCHG MK_HTML=no -DNO_LINT \
MK_MAN=no MK_NLS=no MK_PROFILE=no \
MK_KERBEROS=no MK_RESCUE=no MK_TESTS=no MK_WERROR=no \
TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} \
CPUTYPE=${XDEV_CPUTYPE}
XDDIR=${TARGET_ARCH}-freebsd
XDTP?=/usr/${XDDIR}
.if ${XDTP:N/*}
.error XDTP variable should be an absolute path
.endif
CDBOBJROOT= ${OBJROOT}${MACHINE}.${MACHINE_ARCH}/xdev/
CDBOBJTOP= ${CDBOBJROOT}${XDDIR}
CDBENV= \
INSTALL="sh ${.CURDIR}/tools/install.sh"
CDENV= ${CDBENV} \
TOOLS_PREFIX=${XDTP}
CDMAKEARGS= \
OBJTOP=${CDBOBJTOP:Q} \
OBJROOT=${CDBOBJROOT:Q}
CD2MAKEARGS= ${CDMAKEARGS}
.if ${WANT_COMPILER_TYPE} == gcc || \
(defined(X_COMPILER_TYPE) && ${X_COMPILER_TYPE} == gcc)
# GCC requires -isystem and -L when using a cross-compiler. --sysroot
# won't set header path and -L is used to ensure the base library path
# is added before the port PREFIX library path.
CD2CFLAGS+= -isystem ${XDDESTDIR}/usr/include -L${XDDESTDIR}/usr/lib
# GCC requires -B to find /usr/lib/crti.o when using a cross-compiler
# combined with --sysroot.
CD2CFLAGS+= -B${XDDESTDIR}/usr/lib
# Force using libc++ for external GCC.
.if defined(X_COMPILER_TYPE) && \
${X_COMPILER_TYPE} == gcc && ${X_COMPILER_VERSION} >= 40800
CD2CXXFLAGS+= -isystem ${XDDESTDIR}/usr/include/c++/v1 -std=c++11 \
-nostdinc++
.endif
.endif
CD2CFLAGS+= --sysroot=${XDDESTDIR}/
CD2ENV=${CDENV} CC="${CC} ${CD2CFLAGS}" CXX="${CXX} ${CD2CXXFLAGS} ${CD2CFLAGS}" \
CPP="${CPP} ${CD2CFLAGS}" \
MACHINE=${TARGET} MACHINE_ARCH=${TARGET_ARCH}
CDTMP= ${OBJTOP}/${XDDIR}/tmp
CDMAKE=${CDENV} PATH=${CDTMP}/usr/bin:${PATH} ${MAKE} ${CDMAKEARGS} ${NOFUN}
CD2MAKE=${CD2ENV} PATH=${CDTMP}/usr/bin:${XDDESTDIR}/usr/bin:${PATH} \
${MAKE} ${CD2MAKEARGS} ${NOFUN}
.if ${MK_META_MODE} != "no"
# Don't rebuild build-tools targets during normal build.
CD2MAKE+= BUILD_TOOLS_META=.NOMETA
.endif
XDDESTDIR=${DESTDIR}${XDTP}
.ORDER: xdev-build xdev-install xdev-links
xdev: xdev-build xdev-install .PHONY
.ORDER: _xb-worldtmp _xb-bootstrap-tools _xb-build-tools _xb-cross-tools
xdev-build: _xb-worldtmp _xb-bootstrap-tools _xb-build-tools _xb-cross-tools .PHONY
_xb-worldtmp: .PHONY
mkdir -p ${CDTMP}/usr
${WORLDTMP_MTREE} -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
-p ${CDTMP}/usr >/dev/null
_xb-bootstrap-tools: .PHONY
.for _tool in \
${_clang_tblgen} \
${_yacc}
${_+_}@${ECHODIR} "===> ${_tool} (obj,all,install)"; \
cd ${.CURDIR}/${_tool}; \
if [ -z "${NO_OBJWALK}" ]; then ${CDMAKE} DIRPRFX=${_tool}/ obj; fi; \
${CDMAKE} DIRPRFX=${_tool}/ all; \
${CDMAKE} DIRPRFX=${_tool}/ DESTDIR=${CDTMP} install
.endfor
_xb-build-tools: .PHONY
${_+_}@cd ${.CURDIR}; \
${CDBENV} ${MAKE} ${CDMAKEARGS} -f Makefile.inc1 ${NOFUN} build-tools
XDEVDIRS= \
${_clang_libs} \
${_lld} \
${_elftctools} \
usr.bin/ar \
${_clang}
_xb-cross-tools: .PHONY
.for _tool in ${XDEVDIRS}
${_+_}@${ECHODIR} "===> xdev ${_tool} (obj,all)"; \
cd ${.CURDIR}/${_tool}; \
if [ -z "${NO_OBJWALK}" ]; then ${CDMAKE} DIRPRFX=${_tool}/ obj; fi; \
${CDMAKE} DIRPRFX=${_tool}/ all
.endfor
_xi-mtree: .PHONY
${_+_}@${ECHODIR} "mtree populating ${XDDESTDIR}"
mkdir -p ${XDDESTDIR}
${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.root.dist \
-p ${XDDESTDIR} >/dev/null
${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
-p ${XDDESTDIR}/usr >/dev/null
${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.include.dist \
-p ${XDDESTDIR}/usr/include >/dev/null
.if defined(_LIBCOMPAT)
${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.lib${libcompat}.dist \
-p ${XDDESTDIR}/usr >/dev/null
.endif
.if ${MK_TESTS} != "no"
mkdir -p ${XDDESTDIR}${TESTSBASE}
${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.tests.dist \
-p ${XDDESTDIR}${TESTSBASE} >/dev/null
.endif
.ORDER: xdev-build _xi-mtree _xi-cross-tools _xi-includes _xi-libraries
xdev-install: xdev-build _xi-mtree _xi-cross-tools _xi-includes _xi-libraries .PHONY
_xi-cross-tools: .PHONY
@echo "_xi-cross-tools"
.for _tool in ${XDEVDIRS}
${_+_}@${ECHODIR} "===> xdev ${_tool} (install)"; \
cd ${.CURDIR}/${_tool}; \
${CDMAKE} DIRPRFX=${_tool}/ install DESTDIR=${XDDESTDIR}
.endfor
_xi-includes: .PHONY
.if !defined(NO_OBJWALK)
${_+_}cd ${.CURDIR}; ${CD2MAKE} -f Makefile.inc1 _obj \
DESTDIR=${XDDESTDIR}
.endif
${_+_}cd ${.CURDIR}; ${CD2MAKE} -f Makefile.inc1 includes \
DESTDIR=${XDDESTDIR}
_xi-libraries: .PHONY
${_+_}cd ${.CURDIR}; ${CD2MAKE} -f Makefile.inc1 libraries \
DESTDIR=${XDDESTDIR}
xdev-links: .PHONY
${_+_}cd ${XDDESTDIR}/usr/bin; \
mkdir -p ../../../../usr/bin; \
for i in *; do \
ln -sf ../../${XDTP}/usr/bin/$$i \
../../../../usr/bin/${XDDIR}-$$i; \
ln -sf ../../${XDTP}/usr/bin/$$i \
../../../../usr/bin/${XDDIR}${_REVISION}-$$i; \
done
diff --git a/contrib/llvm-project/clang/lib/Driver/ToolChains/Linux.cpp b/contrib/llvm-project/clang/lib/Driver/ToolChains/Linux.cpp
index af74b108e04e..f85c04df4f6c 100644
--- a/contrib/llvm-project/clang/lib/Driver/ToolChains/Linux.cpp
+++ b/contrib/llvm-project/clang/lib/Driver/ToolChains/Linux.cpp
@@ -1,774 +1,774 @@
//===--- Linux.h - Linux ToolChain Implementations --------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "Linux.h"
#include "Arch/ARM.h"
#include "Arch/Mips.h"
#include "Arch/PPC.h"
#include "Arch/RISCV.h"
#include "CommonArgs.h"
#include "clang/Config/config.h"
#include "clang/Driver/Distro.h"
#include "clang/Driver/Driver.h"
#include "clang/Driver/Options.h"
#include "clang/Driver/SanitizerArgs.h"
#include "llvm/Option/ArgList.h"
#include "llvm/ProfileData/InstrProf.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/ScopedPrinter.h"
#include "llvm/Support/VirtualFileSystem.h"
#include <system_error>
using namespace clang::driver;
using namespace clang::driver::toolchains;
using namespace clang;
using namespace llvm::opt;
using tools::addPathIfExists;
/// Get our best guess at the multiarch triple for a target.
///
/// Debian-based systems are starting to use a multiarch setup where they use
/// a target-triple directory in the library and header search paths.
/// Unfortunately, this triple does not align with the vanilla target triple,
/// so we provide a rough mapping here.
std::string Linux::getMultiarchTriple(const Driver &D,
const llvm::Triple &TargetTriple,
StringRef SysRoot) const {
llvm::Triple::EnvironmentType TargetEnvironment =
TargetTriple.getEnvironment();
bool IsAndroid = TargetTriple.isAndroid();
bool IsMipsR6 = TargetTriple.getSubArch() == llvm::Triple::MipsSubArch_r6;
bool IsMipsN32Abi = TargetTriple.getEnvironment() == llvm::Triple::GNUABIN32;
// For most architectures, just use whatever we have rather than trying to be
// clever.
switch (TargetTriple.getArch()) {
default:
break;
// We use the existence of '/lib/<triple>' as a directory to detect some
// common linux triples that don't quite match the Clang triple for both
// 32-bit and 64-bit targets. Multiarch fixes its install triples to these
// regardless of what the actual target triple is.
case llvm::Triple::arm:
case llvm::Triple::thumb:
if (IsAndroid)
return "arm-linux-androideabi";
if (TargetEnvironment == llvm::Triple::GNUEABIHF)
return "arm-linux-gnueabihf";
return "arm-linux-gnueabi";
case llvm::Triple::armeb:
case llvm::Triple::thumbeb:
if (TargetEnvironment == llvm::Triple::GNUEABIHF)
return "armeb-linux-gnueabihf";
return "armeb-linux-gnueabi";
case llvm::Triple::x86:
if (IsAndroid)
return "i686-linux-android";
return "i386-linux-gnu";
case llvm::Triple::x86_64:
if (IsAndroid)
return "x86_64-linux-android";
if (TargetEnvironment == llvm::Triple::GNUX32)
return "x86_64-linux-gnux32";
return "x86_64-linux-gnu";
case llvm::Triple::aarch64:
if (IsAndroid)
return "aarch64-linux-android";
return "aarch64-linux-gnu";
case llvm::Triple::aarch64_be:
return "aarch64_be-linux-gnu";
case llvm::Triple::m68k:
return "m68k-linux-gnu";
case llvm::Triple::mips:
return IsMipsR6 ? "mipsisa32r6-linux-gnu" : "mips-linux-gnu";
case llvm::Triple::mipsel:
if (IsAndroid)
return "mipsel-linux-android";
return IsMipsR6 ? "mipsisa32r6el-linux-gnu" : "mipsel-linux-gnu";
case llvm::Triple::mips64: {
std::string MT = std::string(IsMipsR6 ? "mipsisa64r6" : "mips64") +
"-linux-" + (IsMipsN32Abi ? "gnuabin32" : "gnuabi64");
if (D.getVFS().exists(SysRoot + "/lib/" + MT))
return MT;
if (D.getVFS().exists(SysRoot + "/lib/mips64-linux-gnu"))
return "mips64-linux-gnu";
break;
}
case llvm::Triple::mips64el: {
if (IsAndroid)
return "mips64el-linux-android";
std::string MT = std::string(IsMipsR6 ? "mipsisa64r6el" : "mips64el") +
"-linux-" + (IsMipsN32Abi ? "gnuabin32" : "gnuabi64");
if (D.getVFS().exists(SysRoot + "/lib/" + MT))
return MT;
if (D.getVFS().exists(SysRoot + "/lib/mips64el-linux-gnu"))
return "mips64el-linux-gnu";
break;
}
case llvm::Triple::ppc:
if (D.getVFS().exists(SysRoot + "/lib/powerpc-linux-gnuspe"))
return "powerpc-linux-gnuspe";
return "powerpc-linux-gnu";
case llvm::Triple::ppcle:
return "powerpcle-linux-gnu";
case llvm::Triple::ppc64:
return "powerpc64-linux-gnu";
case llvm::Triple::ppc64le:
return "powerpc64le-linux-gnu";
case llvm::Triple::sparc:
return "sparc-linux-gnu";
case llvm::Triple::sparcv9:
return "sparc64-linux-gnu";
case llvm::Triple::systemz:
return "s390x-linux-gnu";
}
return TargetTriple.str();
}
static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) {
if (Triple.isMIPS()) {
if (Triple.isAndroid()) {
StringRef CPUName;
StringRef ABIName;
tools::mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
if (CPUName == "mips32r6")
return "libr6";
if (CPUName == "mips32r2")
return "libr2";
}
// lib32 directory has a special meaning on MIPS targets.
// It contains N32 ABI binaries. Use this folder if produce
// code for N32 ABI only.
if (tools::mips::hasMipsAbiArg(Args, "n32"))
return "lib32";
return Triple.isArch32Bit() ? "lib" : "lib64";
}
// It happens that only x86, PPC and SPARC use the 'lib32' variant of
// oslibdir, and using that variant while targeting other architectures causes
// problems because the libraries are laid out in shared system roots that
// can't cope with a 'lib32' library search path being considered. So we only
// enable them when we know we may need it.
//
// FIXME: This is a bit of a hack. We should really unify this code for
// reasoning about oslibdir spellings with the lib dir spellings in the
// GCCInstallationDetector, but that is a more significant refactoring.
if (Triple.getArch() == llvm::Triple::x86 || Triple.isPPC32() ||
Triple.getArch() == llvm::Triple::sparc)
return "lib32";
if (Triple.getArch() == llvm::Triple::x86_64 && Triple.isX32())
return "libx32";
if (Triple.getArch() == llvm::Triple::riscv32)
return "lib32";
return Triple.isArch32Bit() ? "lib" : "lib64";
}
Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
: Generic_ELF(D, Triple, Args) {
GCCInstallation.init(Triple, Args);
Multilibs = GCCInstallation.getMultilibs();
SelectedMultilib = GCCInstallation.getMultilib();
llvm::Triple::ArchType Arch = Triple.getArch();
std::string SysRoot = computeSysRoot();
ToolChain::path_list &PPaths = getProgramPaths();
Generic_GCC::PushPPaths(PPaths);
Distro Distro(D.getVFS(), Triple);
if (Distro.IsAlpineLinux() || Triple.isAndroid()) {
ExtraOpts.push_back("-z");
ExtraOpts.push_back("now");
}
if (Distro.IsOpenSUSE() || Distro.IsUbuntu() || Distro.IsAlpineLinux() ||
Triple.isAndroid()) {
ExtraOpts.push_back("-z");
ExtraOpts.push_back("relro");
}
// Android ARM/AArch64 use max-page-size=4096 to reduce VMA usage. Note, lld
// from 11 onwards default max-page-size to 65536 for both ARM and AArch64.
if ((Triple.isARM() || Triple.isAArch64()) && Triple.isAndroid()) {
ExtraOpts.push_back("-z");
ExtraOpts.push_back("max-page-size=4096");
}
if (GCCInstallation.getParentLibPath().contains("opt/rh/"))
// With devtoolset on RHEL, we want to add a bin directory that is relative
// to the detected gcc install, because if we are using devtoolset gcc then
// we want to use other tools from devtoolset (e.g. ld) instead of the
// standard system tools.
PPaths.push_back(Twine(GCCInstallation.getParentLibPath() +
"/../bin").str());
if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
ExtraOpts.push_back("-X");
const bool IsAndroid = Triple.isAndroid();
const bool IsMips = Triple.isMIPS();
const bool IsHexagon = Arch == llvm::Triple::hexagon;
const bool IsRISCV = Triple.isRISCV();
if (IsMips && !SysRoot.empty())
ExtraOpts.push_back("--sysroot=" + SysRoot);
// Do not use 'gnu' hash style for Mips targets because .gnu.hash
// and the MIPS ABI require .dynsym to be sorted in different ways.
// .gnu.hash needs symbols to be grouped by hash code whereas the MIPS
// ABI requires a mapping between the GOT and the symbol table.
// Android loader does not support .gnu.hash until API 23.
// Hexagon linker/loader does not support .gnu.hash
if (!IsMips && !IsHexagon) {
if (Distro.IsRedhat() || Distro.IsOpenSUSE() || Distro.IsAlpineLinux() ||
(Distro.IsUbuntu() && Distro >= Distro::UbuntuMaverick) ||
(IsAndroid && !Triple.isAndroidVersionLT(23)))
ExtraOpts.push_back("--hash-style=gnu");
if (Distro.IsDebian() || Distro.IsOpenSUSE() ||
Distro == Distro::UbuntuLucid || Distro == Distro::UbuntuJaunty ||
Distro == Distro::UbuntuKarmic ||
(IsAndroid && Triple.isAndroidVersionLT(23)))
ExtraOpts.push_back("--hash-style=both");
}
#ifdef ENABLE_LINKER_BUILD_ID
ExtraOpts.push_back("--build-id");
#endif
if (IsAndroid || Distro.IsOpenSUSE())
ExtraOpts.push_back("--enable-new-dtags");
// The selection of paths to try here is designed to match the patterns which
// the GCC driver itself uses, as this is part of the GCC-compatible driver.
// This was determined by running GCC in a fake filesystem, creating all
// possible permutations of these directories, and seeing which ones it added
// to the link paths.
path_list &Paths = getFilePaths();
const std::string OSLibDir = std::string(getOSLibDir(Triple, Args));
const std::string MultiarchTriple = getMultiarchTriple(D, Triple, SysRoot);
// mips32: Debian multilib, we use /libo32, while in other case, /lib is
// used. We need add both libo32 and /lib.
if (Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel) {
Generic_GCC::AddMultilibPaths(D, SysRoot, "libo32", MultiarchTriple, Paths);
addPathIfExists(D, SysRoot + "/libo32", Paths);
addPathIfExists(D, SysRoot + "/usr/libo32", Paths);
}
Generic_GCC::AddMultilibPaths(D, SysRoot, OSLibDir, MultiarchTriple, Paths);
addPathIfExists(D, SysRoot + "/lib/" + MultiarchTriple, Paths);
addPathIfExists(D, SysRoot + "/lib/../" + OSLibDir, Paths);
if (IsAndroid) {
// Android sysroots contain a library directory for each supported OS
// version as well as some unversioned libraries in the usual multiarch
// directory.
addPathIfExists(
D,
SysRoot + "/usr/lib/" + MultiarchTriple + "/" +
llvm::to_string(Triple.getEnvironmentVersion().getMajor()),
Paths);
}
addPathIfExists(D, SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
// 64-bit OpenEmbedded sysroots may not have a /usr/lib dir. So they cannot
// find /usr/lib64 as it is referenced as /usr/lib/../lib64. So we handle
// this here.
if (Triple.getVendor() == llvm::Triple::OpenEmbedded &&
Triple.isArch64Bit())
addPathIfExists(D, SysRoot + "/usr/" + OSLibDir, Paths);
else
addPathIfExists(D, SysRoot + "/usr/lib/../" + OSLibDir, Paths);
if (IsRISCV) {
StringRef ABIName = tools::riscv::getRISCVABI(Args, Triple);
addPathIfExists(D, SysRoot + "/" + OSLibDir + "/" + ABIName, Paths);
addPathIfExists(D, SysRoot + "/usr/" + OSLibDir + "/" + ABIName, Paths);
}
Generic_GCC::AddMultiarchPaths(D, SysRoot, OSLibDir, Paths);
// Similar to the logic for GCC above, if we are currently running Clang
// inside of the requested system root, add its parent library path to those
// searched.
// FIXME: It's not clear whether we should use the driver's installed
// directory ('Dir' below) or the ResourceDir.
if (StringRef(D.Dir).startswith(SysRoot)) {
// Even if OSLibDir != "lib", this is needed for Clang in the build
// directory (not installed) to find libc++.
addPathIfExists(D, D.Dir + "/../lib", Paths);
if (OSLibDir != "lib")
addPathIfExists(D, D.Dir + "/../" + OSLibDir, Paths);
}
addPathIfExists(D, SysRoot + "/lib", Paths);
addPathIfExists(D, SysRoot + "/usr/lib", Paths);
}
ToolChain::RuntimeLibType Linux::GetDefaultRuntimeLibType() const {
if (getTriple().isAndroid())
return ToolChain::RLT_CompilerRT;
return Generic_ELF::GetDefaultRuntimeLibType();
}
unsigned Linux::GetDefaultDwarfVersion() const {
if (getTriple().isAndroid())
return 4;
return ToolChain::GetDefaultDwarfVersion();
}
ToolChain::CXXStdlibType Linux::GetDefaultCXXStdlibType() const {
if (getTriple().isAndroid())
return ToolChain::CST_Libcxx;
return ToolChain::CST_Libstdcxx;
}
bool Linux::HasNativeLLVMSupport() const { return true; }
Tool *Linux::buildLinker() const { return new tools::gnutools::Linker(*this); }
Tool *Linux::buildStaticLibTool() const {
return new tools::gnutools::StaticLibTool(*this);
}
Tool *Linux::buildAssembler() const {
return new tools::gnutools::Assembler(*this);
}
std::string Linux::computeSysRoot() const {
if (!getDriver().SysRoot.empty())
return getDriver().SysRoot;
if (getTriple().isAndroid()) {
// Android toolchains typically include a sysroot at ../sysroot relative to
// the clang binary.
const StringRef ClangDir = getDriver().getInstalledDir();
std::string AndroidSysRootPath = (ClangDir + "/../sysroot").str();
if (getVFS().exists(AndroidSysRootPath))
return AndroidSysRootPath;
}
if (!GCCInstallation.isValid() || !getTriple().isMIPS())
return std::string();
// Standalone MIPS toolchains use different names for sysroot folder
// and put it into different places. Here we try to check some known
// variants.
const StringRef InstallDir = GCCInstallation.getInstallPath();
const StringRef TripleStr = GCCInstallation.getTriple().str();
const Multilib &Multilib = GCCInstallation.getMultilib();
std::string Path =
(InstallDir + "/../../../../" + TripleStr + "/libc" + Multilib.osSuffix())
.str();
if (getVFS().exists(Path))
return Path;
Path = (InstallDir + "/../../../../sysroot" + Multilib.osSuffix()).str();
if (getVFS().exists(Path))
return Path;
return std::string();
}
std::string Linux::getDynamicLinker(const ArgList &Args) const {
const llvm::Triple::ArchType Arch = getArch();
const llvm::Triple &Triple = getTriple();
const Distro Distro(getDriver().getVFS(), Triple);
if (Triple.isAndroid())
return Triple.isArch64Bit() ? "/system/bin/linker64" : "/system/bin/linker";
if (Triple.isMusl()) {
std::string ArchName;
bool IsArm = false;
switch (Arch) {
case llvm::Triple::arm:
case llvm::Triple::thumb:
ArchName = "arm";
IsArm = true;
break;
case llvm::Triple::armeb:
case llvm::Triple::thumbeb:
ArchName = "armeb";
IsArm = true;
break;
case llvm::Triple::x86:
ArchName = "i386";
break;
case llvm::Triple::x86_64:
ArchName = Triple.isX32() ? "x32" : Triple.getArchName().str();
break;
default:
ArchName = Triple.getArchName().str();
}
if (IsArm &&
(Triple.getEnvironment() == llvm::Triple::MuslEABIHF ||
tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard))
ArchName += "hf";
if (Arch == llvm::Triple::ppc &&
Triple.getSubArch() == llvm::Triple::PPCSubArch_spe)
ArchName = "powerpc-sf";
return "/lib/ld-musl-" + ArchName + ".so.1";
}
std::string LibDir;
std::string Loader;
switch (Arch) {
default:
llvm_unreachable("unsupported architecture");
case llvm::Triple::aarch64:
LibDir = "lib";
Loader = "ld-linux-aarch64.so.1";
break;
case llvm::Triple::aarch64_be:
LibDir = "lib";
Loader = "ld-linux-aarch64_be.so.1";
break;
case llvm::Triple::arm:
case llvm::Triple::thumb:
case llvm::Triple::armeb:
case llvm::Triple::thumbeb: {
const bool HF =
Triple.getEnvironment() == llvm::Triple::GNUEABIHF ||
tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard;
LibDir = "lib";
Loader = HF ? "ld-linux-armhf.so.3" : "ld-linux.so.3";
break;
}
case llvm::Triple::m68k:
LibDir = "lib";
Loader = "ld.so.1";
break;
case llvm::Triple::mips:
case llvm::Triple::mipsel:
case llvm::Triple::mips64:
case llvm::Triple::mips64el: {
bool IsNaN2008 = tools::mips::isNaN2008(getDriver(), Args, Triple);
LibDir = "lib" + tools::mips::getMipsABILibSuffix(Args, Triple);
if (tools::mips::isUCLibc(Args))
Loader = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
else if (!Triple.hasEnvironment() &&
Triple.getVendor() == llvm::Triple::VendorType::MipsTechnologies)
Loader =
Triple.isLittleEndian() ? "ld-musl-mipsel.so.1" : "ld-musl-mips.so.1";
else
Loader = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
break;
}
case llvm::Triple::ppc:
LibDir = "lib";
Loader = "ld.so.1";
break;
case llvm::Triple::ppcle:
LibDir = "lib";
Loader = "ld.so.1";
break;
case llvm::Triple::ppc64:
LibDir = "lib64";
Loader =
(tools::ppc::hasPPCAbiArg(Args, "elfv2")) ? "ld64.so.2" : "ld64.so.1";
break;
case llvm::Triple::ppc64le:
LibDir = "lib64";
Loader =
(tools::ppc::hasPPCAbiArg(Args, "elfv1")) ? "ld64.so.1" : "ld64.so.2";
break;
case llvm::Triple::riscv32: {
StringRef ABIName = tools::riscv::getRISCVABI(Args, Triple);
LibDir = "lib";
Loader = ("ld-linux-riscv32-" + ABIName + ".so.1").str();
break;
}
case llvm::Triple::riscv64: {
StringRef ABIName = tools::riscv::getRISCVABI(Args, Triple);
LibDir = "lib";
Loader = ("ld-linux-riscv64-" + ABIName + ".so.1").str();
break;
}
case llvm::Triple::sparc:
case llvm::Triple::sparcel:
LibDir = "lib";
Loader = "ld-linux.so.2";
break;
case llvm::Triple::sparcv9:
LibDir = "lib64";
Loader = "ld-linux.so.2";
break;
case llvm::Triple::systemz:
LibDir = "lib";
Loader = "ld64.so.1";
break;
case llvm::Triple::x86:
LibDir = "lib";
Loader = "ld-linux.so.2";
break;
case llvm::Triple::x86_64: {
bool X32 = Triple.isX32();
LibDir = X32 ? "libx32" : "lib64";
Loader = X32 ? "ld-linux-x32.so.2" : "ld-linux-x86-64.so.2";
break;
}
case llvm::Triple::ve:
return "/opt/nec/ve/lib/ld-linux-ve.so.1";
}
if (Distro == Distro::Exherbo &&
(Triple.getVendor() == llvm::Triple::UnknownVendor ||
Triple.getVendor() == llvm::Triple::PC))
return "/usr/" + Triple.str() + "/lib/" + Loader;
return "/" + LibDir + "/" + Loader;
}
void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
ArgStringList &CC1Args) const {
const Driver &D = getDriver();
std::string SysRoot = computeSysRoot();
if (DriverArgs.hasArg(clang::driver::options::OPT_nostdinc))
return;
// Add 'include' in the resource directory, which is similar to
// GCC_INCLUDE_DIR (private headers) in GCC. Note: the include directory
// contains some files conflicting with system /usr/include. musl systems
// prefer the /usr/include copies which are more relevant.
SmallString<128> ResourceDirInclude(D.ResourceDir);
llvm::sys::path::append(ResourceDirInclude, "include");
if (!DriverArgs.hasArg(options::OPT_nobuiltininc) &&
(!getTriple().isMusl() || DriverArgs.hasArg(options::OPT_nostdlibinc)))
addSystemInclude(DriverArgs, CC1Args, ResourceDirInclude);
if (DriverArgs.hasArg(options::OPT_nostdlibinc))
return;
// LOCAL_INCLUDE_DIR
addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");
// TOOL_INCLUDE_DIR
AddMultilibIncludeArgs(DriverArgs, CC1Args);
// Check for configure-time C include directories.
StringRef CIncludeDirs(C_INCLUDE_DIRS);
if (CIncludeDirs != "") {
SmallVector<StringRef, 5> dirs;
CIncludeDirs.split(dirs, ":");
for (StringRef dir : dirs) {
StringRef Prefix =
llvm::sys::path::is_absolute(dir) ? "" : StringRef(SysRoot);
addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir);
}
return;
}
// On systems using multiarch and Android, add /usr/include/$triple before
// /usr/include.
std::string MultiarchIncludeDir = getMultiarchTriple(D, getTriple(), SysRoot);
if (!MultiarchIncludeDir.empty() &&
D.getVFS().exists(SysRoot + "/usr/include/" + MultiarchIncludeDir))
addExternCSystemInclude(DriverArgs, CC1Args,
SysRoot + "/usr/include/" + MultiarchIncludeDir);
if (getTriple().getOS() == llvm::Triple::RTEMS)
return;
// Add an include of '/include' directly. This isn't provided by default by
// system GCCs, but is often used with cross-compiling GCCs, and harmless to
// add even when Clang is acting as-if it were a system compiler.
addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
if (!DriverArgs.hasArg(options::OPT_nobuiltininc) && getTriple().isMusl())
addSystemInclude(DriverArgs, CC1Args, ResourceDirInclude);
}
void Linux::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
llvm::opt::ArgStringList &CC1Args) const {
// We need a detected GCC installation on Linux to provide libstdc++'s
// headers in odd Linuxish places.
if (!GCCInstallation.isValid())
return;
// Detect Debian g++-multiarch-incdir.diff.
StringRef TripleStr = GCCInstallation.getTriple().str();
StringRef DebianMultiarch =
GCCInstallation.getTriple().getArch() == llvm::Triple::x86
? "i386-linux-gnu"
: TripleStr;
// Try generic GCC detection first.
if (Generic_GCC::addGCCLibStdCxxIncludePaths(DriverArgs, CC1Args,
DebianMultiarch))
return;
StringRef LibDir = GCCInstallation.getParentLibPath();
const Multilib &Multilib = GCCInstallation.getMultilib();
const GCCVersion &Version = GCCInstallation.getVersion();
const std::string LibStdCXXIncludePathCandidates[] = {
// Android standalone toolchain has C++ headers in yet another place.
LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
// Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++,
// without a subdirectory corresponding to the gcc version.
LibDir.str() + "/../include/c++",
// Cray's gcc installation puts headers under "g++" without a
// version suffix.
LibDir.str() + "/../include/g++",
};
for (const auto &IncludePath : LibStdCXXIncludePathCandidates) {
if (addLibStdCXXIncludePaths(IncludePath, TripleStr,
Multilib.includeSuffix(), DriverArgs, CC1Args))
break;
}
}
void Linux::AddCudaIncludeArgs(const ArgList &DriverArgs,
ArgStringList &CC1Args) const {
CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);
}
void Linux::AddHIPIncludeArgs(const ArgList &DriverArgs,
ArgStringList &CC1Args) const {
RocmInstallation.AddHIPIncludeArgs(DriverArgs, CC1Args);
}
void Linux::AddIAMCUIncludeArgs(const ArgList &DriverArgs,
ArgStringList &CC1Args) const {
if (GCCInstallation.isValid()) {
CC1Args.push_back("-isystem");
CC1Args.push_back(DriverArgs.MakeArgString(
GCCInstallation.getParentLibPath() + "/../" +
GCCInstallation.getTriple().str() + "/include"));
}
}
bool Linux::isPIEDefault(const llvm::opt::ArgList &Args) const {
return CLANG_DEFAULT_PIE_ON_LINUX || getTriple().isAndroid() ||
getTriple().isMusl() || getSanitizerArgs(Args).requiresPIE();
}
bool Linux::IsAArch64OutlineAtomicsDefault(const ArgList &Args) const {
// Outline atomics for AArch64 are supported by compiler-rt
// and libgcc since 9.3.1
assert(getTriple().isAArch64() && "expected AArch64 target!");
ToolChain::RuntimeLibType RtLib = GetRuntimeLibType(Args);
if (RtLib == ToolChain::RLT_CompilerRT)
return true;
assert(RtLib == ToolChain::RLT_Libgcc && "unexpected runtime library type!");
if (GCCInstallation.getVersion().isOlderThan(9, 3, 1))
return false;
return true;
}
bool Linux::IsMathErrnoDefault() const {
- if (getTriple().isAndroid())
+ if (getTriple().isAndroid() || getTriple().isMusl())
return false;
return Generic_ELF::IsMathErrnoDefault();
}
SanitizerMask Linux::getSupportedSanitizers() const {
const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;
const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
const bool IsMIPS = getTriple().isMIPS32();
const bool IsMIPS64 = getTriple().isMIPS64();
const bool IsPowerPC64 = getTriple().getArch() == llvm::Triple::ppc64 ||
getTriple().getArch() == llvm::Triple::ppc64le;
const bool IsAArch64 = getTriple().getArch() == llvm::Triple::aarch64 ||
getTriple().getArch() == llvm::Triple::aarch64_be;
const bool IsArmArch = getTriple().getArch() == llvm::Triple::arm ||
getTriple().getArch() == llvm::Triple::thumb ||
getTriple().getArch() == llvm::Triple::armeb ||
getTriple().getArch() == llvm::Triple::thumbeb;
const bool IsRISCV64 = getTriple().getArch() == llvm::Triple::riscv64;
const bool IsSystemZ = getTriple().getArch() == llvm::Triple::systemz;
const bool IsHexagon = getTriple().getArch() == llvm::Triple::hexagon;
SanitizerMask Res = ToolChain::getSupportedSanitizers();
Res |= SanitizerKind::Address;
Res |= SanitizerKind::PointerCompare;
Res |= SanitizerKind::PointerSubtract;
Res |= SanitizerKind::Fuzzer;
Res |= SanitizerKind::FuzzerNoLink;
Res |= SanitizerKind::KernelAddress;
Res |= SanitizerKind::Memory;
Res |= SanitizerKind::Vptr;
Res |= SanitizerKind::SafeStack;
if (IsX86_64 || IsMIPS64 || IsAArch64)
Res |= SanitizerKind::DataFlow;
if (IsX86_64 || IsMIPS64 || IsAArch64 || IsX86 || IsArmArch || IsPowerPC64 ||
IsRISCV64 || IsSystemZ || IsHexagon)
Res |= SanitizerKind::Leak;
if (IsX86_64 || IsMIPS64 || IsAArch64 || IsPowerPC64 || IsSystemZ)
Res |= SanitizerKind::Thread;
if (IsX86_64)
Res |= SanitizerKind::KernelMemory;
if (IsX86 || IsX86_64)
Res |= SanitizerKind::Function;
if (IsX86_64 || IsMIPS64 || IsAArch64 || IsX86 || IsMIPS || IsArmArch ||
IsPowerPC64 || IsHexagon)
Res |= SanitizerKind::Scudo;
if (IsX86_64 || IsAArch64) {
Res |= SanitizerKind::HWAddress;
Res |= SanitizerKind::KernelHWAddress;
}
return Res;
}
void Linux::addProfileRTLibs(const llvm::opt::ArgList &Args,
llvm::opt::ArgStringList &CmdArgs) const {
// Add linker option -u__llvm_profile_runtime to cause runtime
// initialization module to be linked in.
if (needsProfileRT(Args))
CmdArgs.push_back(Args.MakeArgString(
Twine("-u", llvm::getInstrProfRuntimeHookVarName())));
ToolChain::addProfileRTLibs(Args, CmdArgs);
}
llvm::DenormalMode
Linux::getDefaultDenormalModeForType(const llvm::opt::ArgList &DriverArgs,
const JobAction &JA,
const llvm::fltSemantics *FPType) const {
switch (getTriple().getArch()) {
case llvm::Triple::x86:
case llvm::Triple::x86_64: {
std::string Unused;
// DAZ and FTZ are turned on in crtfastmath.o
if (!DriverArgs.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles) &&
isFastMathRuntimeAvailable(DriverArgs, Unused))
return llvm::DenormalMode::getPreserveSign();
return llvm::DenormalMode::getIEEE();
}
default:
return llvm::DenormalMode::getIEEE();
}
}
void Linux::addExtraOpts(llvm::opt::ArgStringList &CmdArgs) const {
for (const auto &Opt : ExtraOpts)
CmdArgs.push_back(Opt.c_str());
}
diff --git a/contrib/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp b/contrib/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp
index 82048f0eae2e..32b8f47ed633 100644
--- a/contrib/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp
+++ b/contrib/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp
@@ -1,1308 +1,1308 @@
//===-- sanitizer_platform_limits_posix.cpp -------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file is a part of Sanitizer common code.
//
// Sizes and layouts of platform-specific POSIX data structures.
//===----------------------------------------------------------------------===//
#if defined(__linux__) || defined(__APPLE__)
// Tests in this file assume that off_t-dependent data structures match the
// libc ABI. For example, struct dirent here is what readdir() function (as
// exported from libc) returns, and not the user-facing "dirent", which
// depends on _FILE_OFFSET_BITS setting.
// To get this "true" dirent definition, we undefine _FILE_OFFSET_BITS below.
#undef _FILE_OFFSET_BITS
#endif
// Must go after undef _FILE_OFFSET_BITS.
#include "sanitizer_platform.h"
#if SANITIZER_LINUX || SANITIZER_MAC
// Must go after undef _FILE_OFFSET_BITS.
#include "sanitizer_glibc_version.h"
#include <arpa/inet.h>
#include <dirent.h>
#include <grp.h>
#include <limits.h>
#include <net/if.h>
#include <netdb.h>
#include <poll.h>
#include <pthread.h>
#include <pwd.h>
#include <signal.h>
#include <stddef.h>
#include <stdio.h>
#include <sys/mman.h>
#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/times.h>
#include <sys/types.h>
#include <sys/utsname.h>
#include <termios.h>
#include <time.h>
#include <wchar.h>
#include <regex.h>
#if !SANITIZER_MAC
#include <utmp.h>
#endif
#if !SANITIZER_IOS
#include <net/route.h>
#endif
#if !SANITIZER_ANDROID
#include <sys/mount.h>
#include <sys/timeb.h>
#include <utmpx.h>
#endif
#if SANITIZER_LINUX
#include <malloc.h>
#include <mntent.h>
#include <netinet/ether.h>
#include <sys/sysinfo.h>
#include <sys/vt.h>
#include <linux/cdrom.h>
#include <linux/fd.h>
#include <linux/fs.h>
#include <linux/hdreg.h>
#include <linux/input.h>
#include <linux/ioctl.h>
#include <linux/soundcard.h>
#include <linux/sysctl.h>
#include <linux/utsname.h>
#include <linux/posix_types.h>
#include <net/if_arp.h>
#endif
#if SANITIZER_IOS
#undef IOC_DIRMASK
#endif
#if SANITIZER_LINUX
# include <utime.h>
# include <sys/ptrace.h>
# if defined(__mips64) || defined(__aarch64__) || defined(__arm__) || \
defined(__hexagon__) || SANITIZER_RISCV64
# include <asm/ptrace.h>
# ifdef __arm__
typedef struct user_fpregs elf_fpregset_t;
# define ARM_VFPREGS_SIZE_ASAN (32 * 8 /*fpregs*/ + 4 /*fpscr*/)
# if !defined(ARM_VFPREGS_SIZE)
# define ARM_VFPREGS_SIZE ARM_VFPREGS_SIZE_ASAN
# endif
# endif
# endif
# include <semaphore.h>
#endif
#if !SANITIZER_ANDROID
#include <ifaddrs.h>
#include <sys/ucontext.h>
#include <wordexp.h>
#endif
#if SANITIZER_LINUX
#if SANITIZER_GLIBC
#include <fstab.h>
#include <net/if_ppp.h>
#include <netax25/ax25.h>
#include <netipx/ipx.h>
#include <netrom/netrom.h>
#include <obstack.h>
#if HAVE_RPC_XDR_H
# include <rpc/xdr.h>
#endif
#include <scsi/scsi.h>
#else
#include <linux/if_ppp.h>
#include <linux/kd.h>
#include <linux/ppp_defs.h>
#endif // SANITIZER_GLIBC
#if SANITIZER_ANDROID
#include <linux/mtio.h>
#else
#include <glob.h>
#include <mqueue.h>
#include <sys/kd.h>
#include <sys/mtio.h>
#include <sys/shm.h>
#include <sys/statvfs.h>
#include <sys/timex.h>
#if defined(__mips64)
# include <sys/procfs.h>
#endif
#include <sys/user.h>
#include <linux/if_eql.h>
#include <linux/if_plip.h>
#include <linux/lp.h>
#include <linux/mroute.h>
#include <linux/mroute6.h>
#include <linux/scc.h>
#include <linux/serial.h>
#include <sys/msg.h>
#include <sys/ipc.h>
#include <crypt.h>
#endif // SANITIZER_ANDROID
#include <link.h>
#include <sys/vfs.h>
#include <sys/epoll.h>
#include <linux/capability.h>
#else
#include <fstab.h>
#endif // SANITIZER_LINUX
#if SANITIZER_MAC
#include <net/ethernet.h>
#include <sys/filio.h>
#include <sys/sockio.h>
#endif
// Include these after system headers to avoid name clashes and ambiguities.
# include "sanitizer_common.h"
# include "sanitizer_internal_defs.h"
# include "sanitizer_platform_limits_posix.h"
namespace __sanitizer {
unsigned struct_utsname_sz = sizeof(struct utsname);
unsigned struct_stat_sz = sizeof(struct stat);
#if !SANITIZER_IOS && !(SANITIZER_MAC && TARGET_CPU_ARM64)
unsigned struct_stat64_sz = sizeof(struct stat64);
#endif // !SANITIZER_IOS && !(SANITIZER_MAC && TARGET_CPU_ARM64)
unsigned struct_rusage_sz = sizeof(struct rusage);
unsigned struct_tm_sz = sizeof(struct tm);
unsigned struct_passwd_sz = sizeof(struct passwd);
unsigned struct_group_sz = sizeof(struct group);
unsigned siginfo_t_sz = sizeof(siginfo_t);
unsigned struct_sigaction_sz = sizeof(struct sigaction);
unsigned struct_stack_t_sz = sizeof(stack_t);
unsigned struct_itimerval_sz = sizeof(struct itimerval);
unsigned pthread_t_sz = sizeof(pthread_t);
unsigned pthread_mutex_t_sz = sizeof(pthread_mutex_t);
unsigned pthread_cond_t_sz = sizeof(pthread_cond_t);
unsigned pid_t_sz = sizeof(pid_t);
unsigned timeval_sz = sizeof(timeval);
unsigned uid_t_sz = sizeof(uid_t);
unsigned gid_t_sz = sizeof(gid_t);
unsigned mbstate_t_sz = sizeof(mbstate_t);
unsigned sigset_t_sz = sizeof(sigset_t);
unsigned struct_timezone_sz = sizeof(struct timezone);
unsigned struct_tms_sz = sizeof(struct tms);
unsigned struct_sigevent_sz = sizeof(struct sigevent);
unsigned struct_sched_param_sz = sizeof(struct sched_param);
unsigned struct_regex_sz = sizeof(regex_t);
unsigned struct_regmatch_sz = sizeof(regmatch_t);
#if (SANITIZER_MAC && !TARGET_CPU_ARM64) && !SANITIZER_IOS
unsigned struct_statfs64_sz = sizeof(struct statfs64);
#endif // (SANITIZER_MAC && !TARGET_CPU_ARM64) && !SANITIZER_IOS
#if SANITIZER_GLIBC || SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_MAC
unsigned struct_fstab_sz = sizeof(struct fstab);
#endif // SANITIZER_GLIBC || SANITIZER_FREEBSD || SANITIZER_NETBSD ||
// SANITIZER_MAC
#if !SANITIZER_ANDROID
unsigned struct_statfs_sz = sizeof(struct statfs);
unsigned struct_sockaddr_sz = sizeof(struct sockaddr);
unsigned ucontext_t_sz(void *ctx) {
-# if SANITIZER_LINUX && SANITIZER_X64
+# if SANITIZER_GLIBC && SANITIZER_X64
// See kernel arch/x86/kernel/fpu/signal.c for details.
const auto *fpregs = static_cast<ucontext_t *>(ctx)->uc_mcontext.fpregs;
// The member names differ across header versions, but the actual layout
// is always the same. So avoid using members, just use arithmetic.
const uint32_t *after_xmm =
reinterpret_cast<const uint32_t *>(fpregs + 1) - 24;
if (after_xmm[12] == FP_XSTATE_MAGIC1)
return reinterpret_cast<const char *>(fpregs) + after_xmm[13] -
static_cast<const char *>(ctx);
# endif
return sizeof(ucontext_t);
}
# endif // !SANITIZER_ANDROID
# if SANITIZER_LINUX
unsigned struct_epoll_event_sz = sizeof(struct epoll_event);
unsigned struct_sysinfo_sz = sizeof(struct sysinfo);
unsigned __user_cap_header_struct_sz =
sizeof(struct __user_cap_header_struct);
unsigned __user_cap_data_struct_sz = sizeof(struct __user_cap_data_struct);
unsigned struct_new_utsname_sz = sizeof(struct new_utsname);
unsigned struct_old_utsname_sz = sizeof(struct old_utsname);
unsigned struct_oldold_utsname_sz = sizeof(struct oldold_utsname);
#endif // SANITIZER_LINUX
#if SANITIZER_LINUX
unsigned struct_rlimit_sz = sizeof(struct rlimit);
unsigned struct_timespec_sz = sizeof(struct timespec);
unsigned struct_utimbuf_sz = sizeof(struct utimbuf);
unsigned struct_itimerspec_sz = sizeof(struct itimerspec);
#endif // SANITIZER_LINUX
#if SANITIZER_LINUX && !SANITIZER_ANDROID
// Use pre-computed size of struct ustat to avoid <sys/ustat.h> which
// has been removed from glibc 2.28.
#if defined(__aarch64__) || defined(__s390x__) || defined(__mips64) || \
defined(__powerpc64__) || defined(__arch64__) || defined(__sparcv9) || \
defined(__x86_64__) || SANITIZER_RISCV64
#define SIZEOF_STRUCT_USTAT 32
# elif defined(__arm__) || defined(__i386__) || defined(__mips__) || \
defined(__powerpc__) || defined(__s390__) || defined(__sparc__) || \
defined(__hexagon__)
# define SIZEOF_STRUCT_USTAT 20
# else
# error Unknown size of struct ustat
# endif
unsigned struct_ustat_sz = SIZEOF_STRUCT_USTAT;
unsigned struct_rlimit64_sz = sizeof(struct rlimit64);
unsigned struct_statvfs64_sz = sizeof(struct statvfs64);
unsigned struct_crypt_data_sz = sizeof(struct crypt_data);
#endif // SANITIZER_LINUX && !SANITIZER_ANDROID
#if SANITIZER_LINUX && !SANITIZER_ANDROID
unsigned struct_timex_sz = sizeof(struct timex);
unsigned struct_msqid_ds_sz = sizeof(struct msqid_ds);
unsigned struct_mq_attr_sz = sizeof(struct mq_attr);
unsigned struct_statvfs_sz = sizeof(struct statvfs);
#endif // SANITIZER_LINUX && !SANITIZER_ANDROID
const uptr sig_ign = (uptr)SIG_IGN;
const uptr sig_dfl = (uptr)SIG_DFL;
const uptr sig_err = (uptr)SIG_ERR;
const uptr sa_siginfo = (uptr)SA_SIGINFO;
#if SANITIZER_LINUX
int e_tabsz = (int)E_TABSZ;
#endif
#if SANITIZER_LINUX && !SANITIZER_ANDROID
unsigned struct_shminfo_sz = sizeof(struct shminfo);
unsigned struct_shm_info_sz = sizeof(struct shm_info);
int shmctl_ipc_stat = (int)IPC_STAT;
int shmctl_ipc_info = (int)IPC_INFO;
int shmctl_shm_info = (int)SHM_INFO;
int shmctl_shm_stat = (int)SHM_STAT;
#endif
#if !SANITIZER_MAC && !SANITIZER_FREEBSD
unsigned struct_utmp_sz = sizeof(struct utmp);
#endif
#if !SANITIZER_ANDROID
unsigned struct_utmpx_sz = sizeof(struct utmpx);
#endif
int map_fixed = MAP_FIXED;
int af_inet = (int)AF_INET;
int af_inet6 = (int)AF_INET6;
uptr __sanitizer_in_addr_sz(int af) {
if (af == AF_INET)
return sizeof(struct in_addr);
else if (af == AF_INET6)
return sizeof(struct in6_addr);
else
return 0;
}
#if SANITIZER_LINUX
unsigned struct_ElfW_Phdr_sz = sizeof(ElfW(Phdr));
#elif SANITIZER_FREEBSD
unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr);
#endif
#if SANITIZER_GLIBC
int glob_nomatch = GLOB_NOMATCH;
int glob_altdirfunc = GLOB_ALTDIRFUNC;
#endif
# if !SANITIZER_ANDROID
const int wordexp_wrde_dooffs = WRDE_DOOFFS;
# endif // !SANITIZER_ANDROID
#if SANITIZER_LINUX && !SANITIZER_ANDROID && \
(defined(__i386) || defined(__x86_64) || defined(__mips64) || \
defined(__powerpc64__) || defined(__aarch64__) || defined(__arm__) || \
defined(__s390__) || SANITIZER_RISCV64)
#if defined(__mips64) || defined(__powerpc64__) || defined(__arm__)
unsigned struct_user_regs_struct_sz = sizeof(struct pt_regs);
unsigned struct_user_fpregs_struct_sz = sizeof(elf_fpregset_t);
#elif SANITIZER_RISCV64
unsigned struct_user_regs_struct_sz = sizeof(struct user_regs_struct);
unsigned struct_user_fpregs_struct_sz = sizeof(struct __riscv_q_ext_state);
#elif defined(__aarch64__)
unsigned struct_user_regs_struct_sz = sizeof(struct user_pt_regs);
unsigned struct_user_fpregs_struct_sz = sizeof(struct user_fpsimd_state);
#elif defined(__s390__)
unsigned struct_user_regs_struct_sz = sizeof(struct _user_regs_struct);
unsigned struct_user_fpregs_struct_sz = sizeof(struct _user_fpregs_struct);
#else
unsigned struct_user_regs_struct_sz = sizeof(struct user_regs_struct);
unsigned struct_user_fpregs_struct_sz = sizeof(struct user_fpregs_struct);
#endif // __mips64 || __powerpc64__ || __aarch64__
#if defined(__x86_64) || defined(__mips64) || defined(__powerpc64__) || \
defined(__aarch64__) || defined(__arm__) || defined(__s390__) || \
SANITIZER_RISCV64
unsigned struct_user_fpxregs_struct_sz = 0;
#else
unsigned struct_user_fpxregs_struct_sz = sizeof(struct user_fpxregs_struct);
#endif // __x86_64 || __mips64 || __powerpc64__ || __aarch64__ || __arm__
// || __s390__
#ifdef __arm__
unsigned struct_user_vfpregs_struct_sz = ARM_VFPREGS_SIZE;
#else
unsigned struct_user_vfpregs_struct_sz = 0;
#endif
int ptrace_peektext = PTRACE_PEEKTEXT;
int ptrace_peekdata = PTRACE_PEEKDATA;
int ptrace_peekuser = PTRACE_PEEKUSER;
#if (defined(PTRACE_GETREGS) && defined(PTRACE_SETREGS)) || \
(defined(PT_GETREGS) && defined(PT_SETREGS))
int ptrace_getregs = PTRACE_GETREGS;
int ptrace_setregs = PTRACE_SETREGS;
#else
int ptrace_getregs = -1;
int ptrace_setregs = -1;
#endif
#if (defined(PTRACE_GETFPREGS) && defined(PTRACE_SETFPREGS)) || \
(defined(PT_GETFPREGS) && defined(PT_SETFPREGS))
int ptrace_getfpregs = PTRACE_GETFPREGS;
int ptrace_setfpregs = PTRACE_SETFPREGS;
#else
int ptrace_getfpregs = -1;
int ptrace_setfpregs = -1;
#endif
#if (defined(PTRACE_GETFPXREGS) && defined(PTRACE_SETFPXREGS)) || \
(defined(PT_GETFPXREGS) && defined(PT_SETFPXREGS))
int ptrace_getfpxregs = PTRACE_GETFPXREGS;
int ptrace_setfpxregs = PTRACE_SETFPXREGS;
#else
int ptrace_getfpxregs = -1;
int ptrace_setfpxregs = -1;
#endif // PTRACE_GETFPXREGS/PTRACE_SETFPXREGS
#if defined(PTRACE_GETVFPREGS) && defined(PTRACE_SETVFPREGS)
int ptrace_getvfpregs = PTRACE_GETVFPREGS;
int ptrace_setvfpregs = PTRACE_SETVFPREGS;
#else
int ptrace_getvfpregs = -1;
int ptrace_setvfpregs = -1;
#endif
int ptrace_geteventmsg = PTRACE_GETEVENTMSG;
#if (defined(PTRACE_GETSIGINFO) && defined(PTRACE_SETSIGINFO)) || \
(defined(PT_GETSIGINFO) && defined(PT_SETSIGINFO))
int ptrace_getsiginfo = PTRACE_GETSIGINFO;
int ptrace_setsiginfo = PTRACE_SETSIGINFO;
#else
int ptrace_getsiginfo = -1;
int ptrace_setsiginfo = -1;
#endif // PTRACE_GETSIGINFO/PTRACE_SETSIGINFO
#if defined(PTRACE_GETREGSET) && defined(PTRACE_SETREGSET)
int ptrace_getregset = PTRACE_GETREGSET;
int ptrace_setregset = PTRACE_SETREGSET;
#else
int ptrace_getregset = -1;
int ptrace_setregset = -1;
#endif // PTRACE_GETREGSET/PTRACE_SETREGSET
#endif
unsigned path_max = PATH_MAX;
// ioctl arguments
unsigned struct_ifreq_sz = sizeof(struct ifreq);
unsigned struct_termios_sz = sizeof(struct termios);
unsigned struct_winsize_sz = sizeof(struct winsize);
#if SANITIZER_LINUX
unsigned struct_arpreq_sz = sizeof(struct arpreq);
unsigned struct_cdrom_msf_sz = sizeof(struct cdrom_msf);
unsigned struct_cdrom_multisession_sz = sizeof(struct cdrom_multisession);
unsigned struct_cdrom_read_audio_sz = sizeof(struct cdrom_read_audio);
unsigned struct_cdrom_subchnl_sz = sizeof(struct cdrom_subchnl);
unsigned struct_cdrom_ti_sz = sizeof(struct cdrom_ti);
unsigned struct_cdrom_tocentry_sz = sizeof(struct cdrom_tocentry);
unsigned struct_cdrom_tochdr_sz = sizeof(struct cdrom_tochdr);
unsigned struct_cdrom_volctrl_sz = sizeof(struct cdrom_volctrl);
unsigned struct_ff_effect_sz = sizeof(struct ff_effect);
unsigned struct_floppy_drive_params_sz = sizeof(struct floppy_drive_params);
unsigned struct_floppy_drive_struct_sz = sizeof(struct floppy_drive_struct);
unsigned struct_floppy_fdc_state_sz = sizeof(struct floppy_fdc_state);
unsigned struct_floppy_max_errors_sz = sizeof(struct floppy_max_errors);
unsigned struct_floppy_raw_cmd_sz = sizeof(struct floppy_raw_cmd);
unsigned struct_floppy_struct_sz = sizeof(struct floppy_struct);
unsigned struct_floppy_write_errors_sz = sizeof(struct floppy_write_errors);
unsigned struct_format_descr_sz = sizeof(struct format_descr);
unsigned struct_hd_driveid_sz = sizeof(struct hd_driveid);
unsigned struct_hd_geometry_sz = sizeof(struct hd_geometry);
unsigned struct_input_absinfo_sz = sizeof(struct input_absinfo);
unsigned struct_input_id_sz = sizeof(struct input_id);
unsigned struct_mtpos_sz = sizeof(struct mtpos);
unsigned struct_rtentry_sz = sizeof(struct rtentry);
#if SANITIZER_GLIBC || SANITIZER_ANDROID
unsigned struct_termio_sz = sizeof(struct termio);
#endif
unsigned struct_vt_consize_sz = sizeof(struct vt_consize);
unsigned struct_vt_sizes_sz = sizeof(struct vt_sizes);
unsigned struct_vt_stat_sz = sizeof(struct vt_stat);
#endif // SANITIZER_LINUX
#if SANITIZER_LINUX
#if SOUND_VERSION >= 0x040000
unsigned struct_copr_buffer_sz = 0;
unsigned struct_copr_debug_buf_sz = 0;
unsigned struct_copr_msg_sz = 0;
#else
unsigned struct_copr_buffer_sz = sizeof(struct copr_buffer);
unsigned struct_copr_debug_buf_sz = sizeof(struct copr_debug_buf);
unsigned struct_copr_msg_sz = sizeof(struct copr_msg);
#endif
unsigned struct_midi_info_sz = sizeof(struct midi_info);
unsigned struct_mtget_sz = sizeof(struct mtget);
unsigned struct_mtop_sz = sizeof(struct mtop);
unsigned struct_sbi_instrument_sz = sizeof(struct sbi_instrument);
unsigned struct_seq_event_rec_sz = sizeof(struct seq_event_rec);
unsigned struct_synth_info_sz = sizeof(struct synth_info);
unsigned struct_vt_mode_sz = sizeof(struct vt_mode);
#endif // SANITIZER_LINUX
#if SANITIZER_GLIBC
unsigned struct_ax25_parms_struct_sz = sizeof(struct ax25_parms_struct);
#if EV_VERSION > (0x010000)
unsigned struct_input_keymap_entry_sz = sizeof(struct input_keymap_entry);
#else
unsigned struct_input_keymap_entry_sz = 0;
#endif
unsigned struct_ipx_config_data_sz = sizeof(struct ipx_config_data);
unsigned struct_kbdiacrs_sz = sizeof(struct kbdiacrs);
unsigned struct_kbentry_sz = sizeof(struct kbentry);
unsigned struct_kbkeycode_sz = sizeof(struct kbkeycode);
unsigned struct_kbsentry_sz = sizeof(struct kbsentry);
unsigned struct_mtconfiginfo_sz = sizeof(struct mtconfiginfo);
unsigned struct_nr_parms_struct_sz = sizeof(struct nr_parms_struct);
unsigned struct_scc_modem_sz = sizeof(struct scc_modem);
unsigned struct_scc_stat_sz = sizeof(struct scc_stat);
unsigned struct_serial_multiport_struct_sz
= sizeof(struct serial_multiport_struct);
unsigned struct_serial_struct_sz = sizeof(struct serial_struct);
unsigned struct_sockaddr_ax25_sz = sizeof(struct sockaddr_ax25);
unsigned struct_unimapdesc_sz = sizeof(struct unimapdesc);
unsigned struct_unimapinit_sz = sizeof(struct unimapinit);
unsigned struct_audio_buf_info_sz = sizeof(struct audio_buf_info);
unsigned struct_ppp_stats_sz = sizeof(struct ppp_stats);
#endif // SANITIZER_GLIBC
#if !SANITIZER_ANDROID && !SANITIZER_MAC
unsigned struct_sioc_sg_req_sz = sizeof(struct sioc_sg_req);
unsigned struct_sioc_vif_req_sz = sizeof(struct sioc_vif_req);
#endif
const unsigned long __sanitizer_bufsiz = BUFSIZ;
const unsigned IOCTL_NOT_PRESENT = 0;
unsigned IOCTL_FIOASYNC = FIOASYNC;
unsigned IOCTL_FIOCLEX = FIOCLEX;
unsigned IOCTL_FIOGETOWN = FIOGETOWN;
unsigned IOCTL_FIONBIO = FIONBIO;
unsigned IOCTL_FIONCLEX = FIONCLEX;
unsigned IOCTL_FIOSETOWN = FIOSETOWN;
unsigned IOCTL_SIOCADDMULTI = SIOCADDMULTI;
unsigned IOCTL_SIOCATMARK = SIOCATMARK;
unsigned IOCTL_SIOCDELMULTI = SIOCDELMULTI;
unsigned IOCTL_SIOCGIFADDR = SIOCGIFADDR;
unsigned IOCTL_SIOCGIFBRDADDR = SIOCGIFBRDADDR;
unsigned IOCTL_SIOCGIFCONF = SIOCGIFCONF;
unsigned IOCTL_SIOCGIFDSTADDR = SIOCGIFDSTADDR;
unsigned IOCTL_SIOCGIFFLAGS = SIOCGIFFLAGS;
unsigned IOCTL_SIOCGIFMETRIC = SIOCGIFMETRIC;
unsigned IOCTL_SIOCGIFMTU = SIOCGIFMTU;
unsigned IOCTL_SIOCGIFNETMASK = SIOCGIFNETMASK;
unsigned IOCTL_SIOCGPGRP = SIOCGPGRP;
unsigned IOCTL_SIOCSIFADDR = SIOCSIFADDR;
unsigned IOCTL_SIOCSIFBRDADDR = SIOCSIFBRDADDR;
unsigned IOCTL_SIOCSIFDSTADDR = SIOCSIFDSTADDR;
unsigned IOCTL_SIOCSIFFLAGS = SIOCSIFFLAGS;
unsigned IOCTL_SIOCSIFMETRIC = SIOCSIFMETRIC;
unsigned IOCTL_SIOCSIFMTU = SIOCSIFMTU;
unsigned IOCTL_SIOCSIFNETMASK = SIOCSIFNETMASK;
unsigned IOCTL_SIOCSPGRP = SIOCSPGRP;
unsigned IOCTL_TIOCCONS = TIOCCONS;
unsigned IOCTL_TIOCEXCL = TIOCEXCL;
unsigned IOCTL_TIOCGETD = TIOCGETD;
unsigned IOCTL_TIOCGPGRP = TIOCGPGRP;
unsigned IOCTL_TIOCGWINSZ = TIOCGWINSZ;
unsigned IOCTL_TIOCMBIC = TIOCMBIC;
unsigned IOCTL_TIOCMBIS = TIOCMBIS;
unsigned IOCTL_TIOCMGET = TIOCMGET;
unsigned IOCTL_TIOCMSET = TIOCMSET;
unsigned IOCTL_TIOCNOTTY = TIOCNOTTY;
unsigned IOCTL_TIOCNXCL = TIOCNXCL;
unsigned IOCTL_TIOCOUTQ = TIOCOUTQ;
unsigned IOCTL_TIOCPKT = TIOCPKT;
unsigned IOCTL_TIOCSCTTY = TIOCSCTTY;
unsigned IOCTL_TIOCSETD = TIOCSETD;
unsigned IOCTL_TIOCSPGRP = TIOCSPGRP;
unsigned IOCTL_TIOCSTI = TIOCSTI;
unsigned IOCTL_TIOCSWINSZ = TIOCSWINSZ;
#if SANITIZER_LINUX && !SANITIZER_ANDROID
unsigned IOCTL_SIOCGETSGCNT = SIOCGETSGCNT;
unsigned IOCTL_SIOCGETVIFCNT = SIOCGETVIFCNT;
#endif
#if SANITIZER_LINUX
unsigned IOCTL_EVIOCGABS = EVIOCGABS(0);
unsigned IOCTL_EVIOCGBIT = EVIOCGBIT(0, 0);
unsigned IOCTL_EVIOCGEFFECTS = EVIOCGEFFECTS;
unsigned IOCTL_EVIOCGID = EVIOCGID;
unsigned IOCTL_EVIOCGKEY = EVIOCGKEY(0);
unsigned IOCTL_EVIOCGKEYCODE = EVIOCGKEYCODE;
unsigned IOCTL_EVIOCGLED = EVIOCGLED(0);
unsigned IOCTL_EVIOCGNAME = EVIOCGNAME(0);
unsigned IOCTL_EVIOCGPHYS = EVIOCGPHYS(0);
unsigned IOCTL_EVIOCGRAB = EVIOCGRAB;
unsigned IOCTL_EVIOCGREP = EVIOCGREP;
unsigned IOCTL_EVIOCGSND = EVIOCGSND(0);
unsigned IOCTL_EVIOCGSW = EVIOCGSW(0);
unsigned IOCTL_EVIOCGUNIQ = EVIOCGUNIQ(0);
unsigned IOCTL_EVIOCGVERSION = EVIOCGVERSION;
unsigned IOCTL_EVIOCRMFF = EVIOCRMFF;
unsigned IOCTL_EVIOCSABS = EVIOCSABS(0);
unsigned IOCTL_EVIOCSFF = EVIOCSFF;
unsigned IOCTL_EVIOCSKEYCODE = EVIOCSKEYCODE;
unsigned IOCTL_EVIOCSREP = EVIOCSREP;
unsigned IOCTL_BLKFLSBUF = BLKFLSBUF;
unsigned IOCTL_BLKGETSIZE = BLKGETSIZE;
unsigned IOCTL_BLKRAGET = BLKRAGET;
unsigned IOCTL_BLKRASET = BLKRASET;
unsigned IOCTL_BLKROGET = BLKROGET;
unsigned IOCTL_BLKROSET = BLKROSET;
unsigned IOCTL_BLKRRPART = BLKRRPART;
unsigned IOCTL_CDROMAUDIOBUFSIZ = CDROMAUDIOBUFSIZ;
unsigned IOCTL_CDROMEJECT = CDROMEJECT;
unsigned IOCTL_CDROMEJECT_SW = CDROMEJECT_SW;
unsigned IOCTL_CDROMMULTISESSION = CDROMMULTISESSION;
unsigned IOCTL_CDROMPAUSE = CDROMPAUSE;
unsigned IOCTL_CDROMPLAYMSF = CDROMPLAYMSF;
unsigned IOCTL_CDROMPLAYTRKIND = CDROMPLAYTRKIND;
unsigned IOCTL_CDROMREADAUDIO = CDROMREADAUDIO;
unsigned IOCTL_CDROMREADCOOKED = CDROMREADCOOKED;
unsigned IOCTL_CDROMREADMODE1 = CDROMREADMODE1;
unsigned IOCTL_CDROMREADMODE2 = CDROMREADMODE2;
unsigned IOCTL_CDROMREADRAW = CDROMREADRAW;
unsigned IOCTL_CDROMREADTOCENTRY = CDROMREADTOCENTRY;
unsigned IOCTL_CDROMREADTOCHDR = CDROMREADTOCHDR;
unsigned IOCTL_CDROMRESET = CDROMRESET;
unsigned IOCTL_CDROMRESUME = CDROMRESUME;
unsigned IOCTL_CDROMSEEK = CDROMSEEK;
unsigned IOCTL_CDROMSTART = CDROMSTART;
unsigned IOCTL_CDROMSTOP = CDROMSTOP;
unsigned IOCTL_CDROMSUBCHNL = CDROMSUBCHNL;
unsigned IOCTL_CDROMVOLCTRL = CDROMVOLCTRL;
unsigned IOCTL_CDROMVOLREAD = CDROMVOLREAD;
unsigned IOCTL_CDROM_GET_UPC = CDROM_GET_UPC;
unsigned IOCTL_FDCLRPRM = FDCLRPRM;
unsigned IOCTL_FDDEFPRM = FDDEFPRM;
unsigned IOCTL_FDFLUSH = FDFLUSH;
unsigned IOCTL_FDFMTBEG = FDFMTBEG;
unsigned IOCTL_FDFMTEND = FDFMTEND;
unsigned IOCTL_FDFMTTRK = FDFMTTRK;
unsigned IOCTL_FDGETDRVPRM = FDGETDRVPRM;
unsigned IOCTL_FDGETDRVSTAT = FDGETDRVSTAT;
unsigned IOCTL_FDGETDRVTYP = FDGETDRVTYP;
unsigned IOCTL_FDGETFDCSTAT = FDGETFDCSTAT;
unsigned IOCTL_FDGETMAXERRS = FDGETMAXERRS;
unsigned IOCTL_FDGETPRM = FDGETPRM;
unsigned IOCTL_FDMSGOFF = FDMSGOFF;
unsigned IOCTL_FDMSGON = FDMSGON;
unsigned IOCTL_FDPOLLDRVSTAT = FDPOLLDRVSTAT;
unsigned IOCTL_FDRAWCMD = FDRAWCMD;
unsigned IOCTL_FDRESET = FDRESET;
unsigned IOCTL_FDSETDRVPRM = FDSETDRVPRM;
unsigned IOCTL_FDSETEMSGTRESH = FDSETEMSGTRESH;
unsigned IOCTL_FDSETMAXERRS = FDSETMAXERRS;
unsigned IOCTL_FDSETPRM = FDSETPRM;
unsigned IOCTL_FDTWADDLE = FDTWADDLE;
unsigned IOCTL_FDWERRORCLR = FDWERRORCLR;
unsigned IOCTL_FDWERRORGET = FDWERRORGET;
unsigned IOCTL_HDIO_DRIVE_CMD = HDIO_DRIVE_CMD;
unsigned IOCTL_HDIO_GETGEO = HDIO_GETGEO;
unsigned IOCTL_HDIO_GET_32BIT = HDIO_GET_32BIT;
unsigned IOCTL_HDIO_GET_DMA = HDIO_GET_DMA;
unsigned IOCTL_HDIO_GET_IDENTITY = HDIO_GET_IDENTITY;
unsigned IOCTL_HDIO_GET_KEEPSETTINGS = HDIO_GET_KEEPSETTINGS;
unsigned IOCTL_HDIO_GET_MULTCOUNT = HDIO_GET_MULTCOUNT;
unsigned IOCTL_HDIO_GET_NOWERR = HDIO_GET_NOWERR;
unsigned IOCTL_HDIO_GET_UNMASKINTR = HDIO_GET_UNMASKINTR;
unsigned IOCTL_HDIO_SET_32BIT = HDIO_SET_32BIT;
unsigned IOCTL_HDIO_SET_DMA = HDIO_SET_DMA;
unsigned IOCTL_HDIO_SET_KEEPSETTINGS = HDIO_SET_KEEPSETTINGS;
unsigned IOCTL_HDIO_SET_MULTCOUNT = HDIO_SET_MULTCOUNT;
unsigned IOCTL_HDIO_SET_NOWERR = HDIO_SET_NOWERR;
unsigned IOCTL_HDIO_SET_UNMASKINTR = HDIO_SET_UNMASKINTR;
unsigned IOCTL_MTIOCPOS = MTIOCPOS;
unsigned IOCTL_PPPIOCGASYNCMAP = PPPIOCGASYNCMAP;
unsigned IOCTL_PPPIOCGDEBUG = PPPIOCGDEBUG;
unsigned IOCTL_PPPIOCGFLAGS = PPPIOCGFLAGS;
unsigned IOCTL_PPPIOCGUNIT = PPPIOCGUNIT;
unsigned IOCTL_PPPIOCGXASYNCMAP = PPPIOCGXASYNCMAP;
unsigned IOCTL_PPPIOCSASYNCMAP = PPPIOCSASYNCMAP;
unsigned IOCTL_PPPIOCSDEBUG = PPPIOCSDEBUG;
unsigned IOCTL_PPPIOCSFLAGS = PPPIOCSFLAGS;
unsigned IOCTL_PPPIOCSMAXCID = PPPIOCSMAXCID;
unsigned IOCTL_PPPIOCSMRU = PPPIOCSMRU;
unsigned IOCTL_PPPIOCSXASYNCMAP = PPPIOCSXASYNCMAP;
unsigned IOCTL_SIOCADDRT = SIOCADDRT;
unsigned IOCTL_SIOCDARP = SIOCDARP;
unsigned IOCTL_SIOCDELRT = SIOCDELRT;
unsigned IOCTL_SIOCDRARP = SIOCDRARP;
unsigned IOCTL_SIOCGARP = SIOCGARP;
unsigned IOCTL_SIOCGIFENCAP = SIOCGIFENCAP;
unsigned IOCTL_SIOCGIFHWADDR = SIOCGIFHWADDR;
unsigned IOCTL_SIOCGIFMAP = SIOCGIFMAP;
unsigned IOCTL_SIOCGIFMEM = SIOCGIFMEM;
unsigned IOCTL_SIOCGIFNAME = SIOCGIFNAME;
unsigned IOCTL_SIOCGIFSLAVE = SIOCGIFSLAVE;
unsigned IOCTL_SIOCGRARP = SIOCGRARP;
unsigned IOCTL_SIOCGSTAMP = SIOCGSTAMP;
unsigned IOCTL_SIOCSARP = SIOCSARP;
unsigned IOCTL_SIOCSIFENCAP = SIOCSIFENCAP;
unsigned IOCTL_SIOCSIFHWADDR = SIOCSIFHWADDR;
unsigned IOCTL_SIOCSIFLINK = SIOCSIFLINK;
unsigned IOCTL_SIOCSIFMAP = SIOCSIFMAP;
unsigned IOCTL_SIOCSIFMEM = SIOCSIFMEM;
unsigned IOCTL_SIOCSIFSLAVE = SIOCSIFSLAVE;
unsigned IOCTL_SIOCSRARP = SIOCSRARP;
# if SOUND_VERSION >= 0x040000
unsigned IOCTL_SNDCTL_COPR_HALT = IOCTL_NOT_PRESENT;
unsigned IOCTL_SNDCTL_COPR_LOAD = IOCTL_NOT_PRESENT;
unsigned IOCTL_SNDCTL_COPR_RCODE = IOCTL_NOT_PRESENT;
unsigned IOCTL_SNDCTL_COPR_RCVMSG = IOCTL_NOT_PRESENT;
unsigned IOCTL_SNDCTL_COPR_RDATA = IOCTL_NOT_PRESENT;
unsigned IOCTL_SNDCTL_COPR_RESET = IOCTL_NOT_PRESENT;
unsigned IOCTL_SNDCTL_COPR_RUN = IOCTL_NOT_PRESENT;
unsigned IOCTL_SNDCTL_COPR_SENDMSG = IOCTL_NOT_PRESENT;
unsigned IOCTL_SNDCTL_COPR_WCODE = IOCTL_NOT_PRESENT;
unsigned IOCTL_SNDCTL_COPR_WDATA = IOCTL_NOT_PRESENT;
unsigned IOCTL_SOUND_PCM_READ_BITS = IOCTL_NOT_PRESENT;
unsigned IOCTL_SOUND_PCM_READ_CHANNELS = IOCTL_NOT_PRESENT;
unsigned IOCTL_SOUND_PCM_READ_FILTER = IOCTL_NOT_PRESENT;
unsigned IOCTL_SOUND_PCM_READ_RATE = IOCTL_NOT_PRESENT;
unsigned IOCTL_SOUND_PCM_WRITE_CHANNELS = IOCTL_NOT_PRESENT;
unsigned IOCTL_SOUND_PCM_WRITE_FILTER = IOCTL_NOT_PRESENT;
# else // SOUND_VERSION
unsigned IOCTL_SNDCTL_COPR_HALT = SNDCTL_COPR_HALT;
unsigned IOCTL_SNDCTL_COPR_LOAD = SNDCTL_COPR_LOAD;
unsigned IOCTL_SNDCTL_COPR_RCODE = SNDCTL_COPR_RCODE;
unsigned IOCTL_SNDCTL_COPR_RCVMSG = SNDCTL_COPR_RCVMSG;
unsigned IOCTL_SNDCTL_COPR_RDATA = SNDCTL_COPR_RDATA;
unsigned IOCTL_SNDCTL_COPR_RESET = SNDCTL_COPR_RESET;
unsigned IOCTL_SNDCTL_COPR_RUN = SNDCTL_COPR_RUN;
unsigned IOCTL_SNDCTL_COPR_SENDMSG = SNDCTL_COPR_SENDMSG;
unsigned IOCTL_SNDCTL_COPR_WCODE = SNDCTL_COPR_WCODE;
unsigned IOCTL_SNDCTL_COPR_WDATA = SNDCTL_COPR_WDATA;
unsigned IOCTL_SOUND_PCM_READ_BITS = SOUND_PCM_READ_BITS;
unsigned IOCTL_SOUND_PCM_READ_CHANNELS = SOUND_PCM_READ_CHANNELS;
unsigned IOCTL_SOUND_PCM_READ_FILTER = SOUND_PCM_READ_FILTER;
unsigned IOCTL_SOUND_PCM_READ_RATE = SOUND_PCM_READ_RATE;
unsigned IOCTL_SOUND_PCM_WRITE_CHANNELS = SOUND_PCM_WRITE_CHANNELS;
unsigned IOCTL_SOUND_PCM_WRITE_FILTER = SOUND_PCM_WRITE_FILTER;
#endif // SOUND_VERSION
unsigned IOCTL_TCFLSH = TCFLSH;
unsigned IOCTL_TCGETA = TCGETA;
unsigned IOCTL_TCGETS = TCGETS;
unsigned IOCTL_TCSBRK = TCSBRK;
unsigned IOCTL_TCSBRKP = TCSBRKP;
unsigned IOCTL_TCSETA = TCSETA;
unsigned IOCTL_TCSETAF = TCSETAF;
unsigned IOCTL_TCSETAW = TCSETAW;
unsigned IOCTL_TCSETS = TCSETS;
unsigned IOCTL_TCSETSF = TCSETSF;
unsigned IOCTL_TCSETSW = TCSETSW;
unsigned IOCTL_TCXONC = TCXONC;
unsigned IOCTL_TIOCGLCKTRMIOS = TIOCGLCKTRMIOS;
unsigned IOCTL_TIOCGSOFTCAR = TIOCGSOFTCAR;
unsigned IOCTL_TIOCINQ = TIOCINQ;
unsigned IOCTL_TIOCLINUX = TIOCLINUX;
unsigned IOCTL_TIOCSERCONFIG = TIOCSERCONFIG;
unsigned IOCTL_TIOCSERGETLSR = TIOCSERGETLSR;
unsigned IOCTL_TIOCSERGWILD = TIOCSERGWILD;
unsigned IOCTL_TIOCSERSWILD = TIOCSERSWILD;
unsigned IOCTL_TIOCSLCKTRMIOS = TIOCSLCKTRMIOS;
unsigned IOCTL_TIOCSSOFTCAR = TIOCSSOFTCAR;
unsigned IOCTL_VT_DISALLOCATE = VT_DISALLOCATE;
unsigned IOCTL_VT_GETSTATE = VT_GETSTATE;
unsigned IOCTL_VT_RESIZE = VT_RESIZE;
unsigned IOCTL_VT_RESIZEX = VT_RESIZEX;
unsigned IOCTL_VT_SENDSIG = VT_SENDSIG;
unsigned IOCTL_MTIOCGET = MTIOCGET;
unsigned IOCTL_MTIOCTOP = MTIOCTOP;
unsigned IOCTL_SNDCTL_DSP_GETBLKSIZE = SNDCTL_DSP_GETBLKSIZE;
unsigned IOCTL_SNDCTL_DSP_GETFMTS = SNDCTL_DSP_GETFMTS;
unsigned IOCTL_SNDCTL_DSP_NONBLOCK = SNDCTL_DSP_NONBLOCK;
unsigned IOCTL_SNDCTL_DSP_POST = SNDCTL_DSP_POST;
unsigned IOCTL_SNDCTL_DSP_RESET = SNDCTL_DSP_RESET;
unsigned IOCTL_SNDCTL_DSP_SETFMT = SNDCTL_DSP_SETFMT;
unsigned IOCTL_SNDCTL_DSP_SETFRAGMENT = SNDCTL_DSP_SETFRAGMENT;
unsigned IOCTL_SNDCTL_DSP_SPEED = SNDCTL_DSP_SPEED;
unsigned IOCTL_SNDCTL_DSP_STEREO = SNDCTL_DSP_STEREO;
unsigned IOCTL_SNDCTL_DSP_SUBDIVIDE = SNDCTL_DSP_SUBDIVIDE;
unsigned IOCTL_SNDCTL_DSP_SYNC = SNDCTL_DSP_SYNC;
unsigned IOCTL_SNDCTL_FM_4OP_ENABLE = SNDCTL_FM_4OP_ENABLE;
unsigned IOCTL_SNDCTL_FM_LOAD_INSTR = SNDCTL_FM_LOAD_INSTR;
unsigned IOCTL_SNDCTL_MIDI_INFO = SNDCTL_MIDI_INFO;
unsigned IOCTL_SNDCTL_MIDI_PRETIME = SNDCTL_MIDI_PRETIME;
unsigned IOCTL_SNDCTL_SEQ_CTRLRATE = SNDCTL_SEQ_CTRLRATE;
unsigned IOCTL_SNDCTL_SEQ_GETINCOUNT = SNDCTL_SEQ_GETINCOUNT;
unsigned IOCTL_SNDCTL_SEQ_GETOUTCOUNT = SNDCTL_SEQ_GETOUTCOUNT;
unsigned IOCTL_SNDCTL_SEQ_NRMIDIS = SNDCTL_SEQ_NRMIDIS;
unsigned IOCTL_SNDCTL_SEQ_NRSYNTHS = SNDCTL_SEQ_NRSYNTHS;
unsigned IOCTL_SNDCTL_SEQ_OUTOFBAND = SNDCTL_SEQ_OUTOFBAND;
unsigned IOCTL_SNDCTL_SEQ_PANIC = SNDCTL_SEQ_PANIC;
unsigned IOCTL_SNDCTL_SEQ_PERCMODE = SNDCTL_SEQ_PERCMODE;
unsigned IOCTL_SNDCTL_SEQ_RESET = SNDCTL_SEQ_RESET;
unsigned IOCTL_SNDCTL_SEQ_RESETSAMPLES = SNDCTL_SEQ_RESETSAMPLES;
unsigned IOCTL_SNDCTL_SEQ_SYNC = SNDCTL_SEQ_SYNC;
unsigned IOCTL_SNDCTL_SEQ_TESTMIDI = SNDCTL_SEQ_TESTMIDI;
unsigned IOCTL_SNDCTL_SEQ_THRESHOLD = SNDCTL_SEQ_THRESHOLD;
unsigned IOCTL_SNDCTL_SYNTH_INFO = SNDCTL_SYNTH_INFO;
unsigned IOCTL_SNDCTL_SYNTH_MEMAVL = SNDCTL_SYNTH_MEMAVL;
unsigned IOCTL_SNDCTL_TMR_CONTINUE = SNDCTL_TMR_CONTINUE;
unsigned IOCTL_SNDCTL_TMR_METRONOME = SNDCTL_TMR_METRONOME;
unsigned IOCTL_SNDCTL_TMR_SELECT = SNDCTL_TMR_SELECT;
unsigned IOCTL_SNDCTL_TMR_SOURCE = SNDCTL_TMR_SOURCE;
unsigned IOCTL_SNDCTL_TMR_START = SNDCTL_TMR_START;
unsigned IOCTL_SNDCTL_TMR_STOP = SNDCTL_TMR_STOP;
unsigned IOCTL_SNDCTL_TMR_TEMPO = SNDCTL_TMR_TEMPO;
unsigned IOCTL_SNDCTL_TMR_TIMEBASE = SNDCTL_TMR_TIMEBASE;
unsigned IOCTL_SOUND_MIXER_READ_ALTPCM = SOUND_MIXER_READ_ALTPCM;
unsigned IOCTL_SOUND_MIXER_READ_BASS = SOUND_MIXER_READ_BASS;
unsigned IOCTL_SOUND_MIXER_READ_CAPS = SOUND_MIXER_READ_CAPS;
unsigned IOCTL_SOUND_MIXER_READ_CD = SOUND_MIXER_READ_CD;
unsigned IOCTL_SOUND_MIXER_READ_DEVMASK = SOUND_MIXER_READ_DEVMASK;
unsigned IOCTL_SOUND_MIXER_READ_ENHANCE = SOUND_MIXER_READ_ENHANCE;
unsigned IOCTL_SOUND_MIXER_READ_IGAIN = SOUND_MIXER_READ_IGAIN;
unsigned IOCTL_SOUND_MIXER_READ_IMIX = SOUND_MIXER_READ_IMIX;
unsigned IOCTL_SOUND_MIXER_READ_LINE = SOUND_MIXER_READ_LINE;
unsigned IOCTL_SOUND_MIXER_READ_LINE1 = SOUND_MIXER_READ_LINE1;
unsigned IOCTL_SOUND_MIXER_READ_LINE2 = SOUND_MIXER_READ_LINE2;
unsigned IOCTL_SOUND_MIXER_READ_LINE3 = SOUND_MIXER_READ_LINE3;
unsigned IOCTL_SOUND_MIXER_READ_LOUD = SOUND_MIXER_READ_LOUD;
unsigned IOCTL_SOUND_MIXER_READ_MIC = SOUND_MIXER_READ_MIC;
unsigned IOCTL_SOUND_MIXER_READ_MUTE = SOUND_MIXER_READ_MUTE;
unsigned IOCTL_SOUND_MIXER_READ_OGAIN = SOUND_MIXER_READ_OGAIN;
unsigned IOCTL_SOUND_MIXER_READ_PCM = SOUND_MIXER_READ_PCM;
unsigned IOCTL_SOUND_MIXER_READ_RECLEV = SOUND_MIXER_READ_RECLEV;
unsigned IOCTL_SOUND_MIXER_READ_RECMASK = SOUND_MIXER_READ_RECMASK;
unsigned IOCTL_SOUND_MIXER_READ_RECSRC = SOUND_MIXER_READ_RECSRC;
unsigned IOCTL_SOUND_MIXER_READ_SPEAKER = SOUND_MIXER_READ_SPEAKER;
unsigned IOCTL_SOUND_MIXER_READ_STEREODEVS = SOUND_MIXER_READ_STEREODEVS;
unsigned IOCTL_SOUND_MIXER_READ_SYNTH = SOUND_MIXER_READ_SYNTH;
unsigned IOCTL_SOUND_MIXER_READ_TREBLE = SOUND_MIXER_READ_TREBLE;
unsigned IOCTL_SOUND_MIXER_READ_VOLUME = SOUND_MIXER_READ_VOLUME;
unsigned IOCTL_SOUND_MIXER_WRITE_ALTPCM = SOUND_MIXER_WRITE_ALTPCM;
unsigned IOCTL_SOUND_MIXER_WRITE_BASS = SOUND_MIXER_WRITE_BASS;
unsigned IOCTL_SOUND_MIXER_WRITE_CD = SOUND_MIXER_WRITE_CD;
unsigned IOCTL_SOUND_MIXER_WRITE_ENHANCE = SOUND_MIXER_WRITE_ENHANCE;
unsigned IOCTL_SOUND_MIXER_WRITE_IGAIN = SOUND_MIXER_WRITE_IGAIN;
unsigned IOCTL_SOUND_MIXER_WRITE_IMIX = SOUND_MIXER_WRITE_IMIX;
unsigned IOCTL_SOUND_MIXER_WRITE_LINE = SOUND_MIXER_WRITE_LINE;
unsigned IOCTL_SOUND_MIXER_WRITE_LINE1 = SOUND_MIXER_WRITE_LINE1;
unsigned IOCTL_SOUND_MIXER_WRITE_LINE2 = SOUND_MIXER_WRITE_LINE2;
unsigned IOCTL_SOUND_MIXER_WRITE_LINE3 = SOUND_MIXER_WRITE_LINE3;
unsigned IOCTL_SOUND_MIXER_WRITE_LOUD = SOUND_MIXER_WRITE_LOUD;
unsigned IOCTL_SOUND_MIXER_WRITE_MIC = SOUND_MIXER_WRITE_MIC;
unsigned IOCTL_SOUND_MIXER_WRITE_MUTE = SOUND_MIXER_WRITE_MUTE;
unsigned IOCTL_SOUND_MIXER_WRITE_OGAIN = SOUND_MIXER_WRITE_OGAIN;
unsigned IOCTL_SOUND_MIXER_WRITE_PCM = SOUND_MIXER_WRITE_PCM;
unsigned IOCTL_SOUND_MIXER_WRITE_RECLEV = SOUND_MIXER_WRITE_RECLEV;
unsigned IOCTL_SOUND_MIXER_WRITE_RECSRC = SOUND_MIXER_WRITE_RECSRC;
unsigned IOCTL_SOUND_MIXER_WRITE_SPEAKER = SOUND_MIXER_WRITE_SPEAKER;
unsigned IOCTL_SOUND_MIXER_WRITE_SYNTH = SOUND_MIXER_WRITE_SYNTH;
unsigned IOCTL_SOUND_MIXER_WRITE_TREBLE = SOUND_MIXER_WRITE_TREBLE;
unsigned IOCTL_SOUND_MIXER_WRITE_VOLUME = SOUND_MIXER_WRITE_VOLUME;
unsigned IOCTL_VT_ACTIVATE = VT_ACTIVATE;
unsigned IOCTL_VT_GETMODE = VT_GETMODE;
unsigned IOCTL_VT_OPENQRY = VT_OPENQRY;
unsigned IOCTL_VT_RELDISP = VT_RELDISP;
unsigned IOCTL_VT_SETMODE = VT_SETMODE;
unsigned IOCTL_VT_WAITACTIVE = VT_WAITACTIVE;
#endif // SANITIZER_LINUX
#if SANITIZER_LINUX && !SANITIZER_ANDROID
unsigned IOCTL_EQL_EMANCIPATE = EQL_EMANCIPATE;
unsigned IOCTL_EQL_ENSLAVE = EQL_ENSLAVE;
unsigned IOCTL_EQL_GETMASTRCFG = EQL_GETMASTRCFG;
unsigned IOCTL_EQL_GETSLAVECFG = EQL_GETSLAVECFG;
unsigned IOCTL_EQL_SETMASTRCFG = EQL_SETMASTRCFG;
unsigned IOCTL_EQL_SETSLAVECFG = EQL_SETSLAVECFG;
#if EV_VERSION > (0x010000)
unsigned IOCTL_EVIOCGKEYCODE_V2 = EVIOCGKEYCODE_V2;
unsigned IOCTL_EVIOCGPROP = EVIOCGPROP(0);
unsigned IOCTL_EVIOCSKEYCODE_V2 = EVIOCSKEYCODE_V2;
#else
unsigned IOCTL_EVIOCGKEYCODE_V2 = IOCTL_NOT_PRESENT;
unsigned IOCTL_EVIOCGPROP = IOCTL_NOT_PRESENT;
unsigned IOCTL_EVIOCSKEYCODE_V2 = IOCTL_NOT_PRESENT;
#endif
unsigned IOCTL_FS_IOC_GETFLAGS = FS_IOC_GETFLAGS;
unsigned IOCTL_FS_IOC_GETVERSION = FS_IOC_GETVERSION;
unsigned IOCTL_FS_IOC_SETFLAGS = FS_IOC_SETFLAGS;
unsigned IOCTL_FS_IOC_SETVERSION = FS_IOC_SETVERSION;
unsigned IOCTL_GIO_CMAP = GIO_CMAP;
unsigned IOCTL_GIO_FONT = GIO_FONT;
unsigned IOCTL_GIO_UNIMAP = GIO_UNIMAP;
unsigned IOCTL_GIO_UNISCRNMAP = GIO_UNISCRNMAP;
unsigned IOCTL_KDADDIO = KDADDIO;
unsigned IOCTL_KDDELIO = KDDELIO;
unsigned IOCTL_KDGETKEYCODE = KDGETKEYCODE;
unsigned IOCTL_KDGKBDIACR = KDGKBDIACR;
unsigned IOCTL_KDGKBENT = KDGKBENT;
unsigned IOCTL_KDGKBLED = KDGKBLED;
unsigned IOCTL_KDGKBMETA = KDGKBMETA;
unsigned IOCTL_KDGKBSENT = KDGKBSENT;
unsigned IOCTL_KDMAPDISP = KDMAPDISP;
unsigned IOCTL_KDSETKEYCODE = KDSETKEYCODE;
unsigned IOCTL_KDSIGACCEPT = KDSIGACCEPT;
unsigned IOCTL_KDSKBDIACR = KDSKBDIACR;
unsigned IOCTL_KDSKBENT = KDSKBENT;
unsigned IOCTL_KDSKBLED = KDSKBLED;
unsigned IOCTL_KDSKBMETA = KDSKBMETA;
unsigned IOCTL_KDSKBSENT = KDSKBSENT;
unsigned IOCTL_KDUNMAPDISP = KDUNMAPDISP;
unsigned IOCTL_LPABORT = LPABORT;
unsigned IOCTL_LPABORTOPEN = LPABORTOPEN;
unsigned IOCTL_LPCAREFUL = LPCAREFUL;
unsigned IOCTL_LPCHAR = LPCHAR;
unsigned IOCTL_LPGETIRQ = LPGETIRQ;
unsigned IOCTL_LPGETSTATUS = LPGETSTATUS;
unsigned IOCTL_LPRESET = LPRESET;
unsigned IOCTL_LPSETIRQ = LPSETIRQ;
unsigned IOCTL_LPTIME = LPTIME;
unsigned IOCTL_LPWAIT = LPWAIT;
unsigned IOCTL_MTIOCGETCONFIG = MTIOCGETCONFIG;
unsigned IOCTL_MTIOCSETCONFIG = MTIOCSETCONFIG;
unsigned IOCTL_PIO_CMAP = PIO_CMAP;
unsigned IOCTL_PIO_FONT = PIO_FONT;
unsigned IOCTL_PIO_UNIMAP = PIO_UNIMAP;
unsigned IOCTL_PIO_UNIMAPCLR = PIO_UNIMAPCLR;
unsigned IOCTL_PIO_UNISCRNMAP = PIO_UNISCRNMAP;
#if SANITIZER_GLIBC
unsigned IOCTL_SCSI_IOCTL_GET_IDLUN = SCSI_IOCTL_GET_IDLUN;
unsigned IOCTL_SCSI_IOCTL_PROBE_HOST = SCSI_IOCTL_PROBE_HOST;
unsigned IOCTL_SCSI_IOCTL_TAGGED_DISABLE = SCSI_IOCTL_TAGGED_DISABLE;
unsigned IOCTL_SCSI_IOCTL_TAGGED_ENABLE = SCSI_IOCTL_TAGGED_ENABLE;
unsigned IOCTL_SIOCAIPXITFCRT = SIOCAIPXITFCRT;
unsigned IOCTL_SIOCAIPXPRISLT = SIOCAIPXPRISLT;
unsigned IOCTL_SIOCAX25ADDUID = SIOCAX25ADDUID;
unsigned IOCTL_SIOCAX25DELUID = SIOCAX25DELUID;
unsigned IOCTL_SIOCAX25GETPARMS = SIOCAX25GETPARMS;
unsigned IOCTL_SIOCAX25GETUID = SIOCAX25GETUID;
unsigned IOCTL_SIOCAX25NOUID = SIOCAX25NOUID;
unsigned IOCTL_SIOCAX25SETPARMS = SIOCAX25SETPARMS;
unsigned IOCTL_SIOCDEVPLIP = SIOCDEVPLIP;
unsigned IOCTL_SIOCIPXCFGDATA = SIOCIPXCFGDATA;
unsigned IOCTL_SIOCNRDECOBS = SIOCNRDECOBS;
unsigned IOCTL_SIOCNRGETPARMS = SIOCNRGETPARMS;
unsigned IOCTL_SIOCNRRTCTL = SIOCNRRTCTL;
unsigned IOCTL_SIOCNRSETPARMS = SIOCNRSETPARMS;
#endif
unsigned IOCTL_TIOCGSERIAL = TIOCGSERIAL;
unsigned IOCTL_TIOCSERGETMULTI = TIOCSERGETMULTI;
unsigned IOCTL_TIOCSERSETMULTI = TIOCSERSETMULTI;
unsigned IOCTL_TIOCSSERIAL = TIOCSSERIAL;
#endif // SANITIZER_LINUX && !SANITIZER_ANDROID
#if SANITIZER_LINUX && !SANITIZER_ANDROID
unsigned IOCTL_GIO_SCRNMAP = GIO_SCRNMAP;
unsigned IOCTL_KDDISABIO = KDDISABIO;
unsigned IOCTL_KDENABIO = KDENABIO;
unsigned IOCTL_KDGETLED = KDGETLED;
unsigned IOCTL_KDGETMODE = KDGETMODE;
unsigned IOCTL_KDGKBMODE = KDGKBMODE;
unsigned IOCTL_KDGKBTYPE = KDGKBTYPE;
unsigned IOCTL_KDMKTONE = KDMKTONE;
unsigned IOCTL_KDSETLED = KDSETLED;
unsigned IOCTL_KDSETMODE = KDSETMODE;
unsigned IOCTL_KDSKBMODE = KDSKBMODE;
unsigned IOCTL_KIOCSOUND = KIOCSOUND;
unsigned IOCTL_PIO_SCRNMAP = PIO_SCRNMAP;
unsigned IOCTL_SNDCTL_DSP_GETISPACE = SNDCTL_DSP_GETISPACE;
unsigned IOCTL_SNDCTL_DSP_GETOSPACE = SNDCTL_DSP_GETOSPACE;
#endif // (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
const int si_SEGV_MAPERR = SEGV_MAPERR;
const int si_SEGV_ACCERR = SEGV_ACCERR;
} // namespace __sanitizer
using namespace __sanitizer;
COMPILER_CHECK(sizeof(__sanitizer_pthread_attr_t) >= sizeof(pthread_attr_t));
COMPILER_CHECK(sizeof(socklen_t) == sizeof(unsigned));
CHECK_TYPE_SIZE(pthread_key_t);
#if SANITIZER_LINUX
// FIXME: We define those on Linux and Mac, but only check on Linux.
COMPILER_CHECK(IOC_NRBITS == _IOC_NRBITS);
COMPILER_CHECK(IOC_TYPEBITS == _IOC_TYPEBITS);
COMPILER_CHECK(IOC_SIZEBITS == _IOC_SIZEBITS);
COMPILER_CHECK(IOC_DIRBITS == _IOC_DIRBITS);
COMPILER_CHECK(IOC_NRMASK == _IOC_NRMASK);
COMPILER_CHECK(IOC_TYPEMASK == _IOC_TYPEMASK);
COMPILER_CHECK(IOC_SIZEMASK == _IOC_SIZEMASK);
COMPILER_CHECK(IOC_DIRMASK == _IOC_DIRMASK);
COMPILER_CHECK(IOC_NRSHIFT == _IOC_NRSHIFT);
COMPILER_CHECK(IOC_TYPESHIFT == _IOC_TYPESHIFT);
COMPILER_CHECK(IOC_SIZESHIFT == _IOC_SIZESHIFT);
COMPILER_CHECK(IOC_DIRSHIFT == _IOC_DIRSHIFT);
COMPILER_CHECK(IOC_NONE == _IOC_NONE);
COMPILER_CHECK(IOC_WRITE == _IOC_WRITE);
COMPILER_CHECK(IOC_READ == _IOC_READ);
COMPILER_CHECK(EVIOC_ABS_MAX == ABS_MAX);
COMPILER_CHECK(EVIOC_EV_MAX == EV_MAX);
COMPILER_CHECK(IOC_SIZE(0x12345678) == _IOC_SIZE(0x12345678));
COMPILER_CHECK(IOC_DIR(0x12345678) == _IOC_DIR(0x12345678));
COMPILER_CHECK(IOC_NR(0x12345678) == _IOC_NR(0x12345678));
COMPILER_CHECK(IOC_TYPE(0x12345678) == _IOC_TYPE(0x12345678));
#endif // SANITIZER_LINUX
#if SANITIZER_LINUX || SANITIZER_FREEBSD
// There are more undocumented fields in dl_phdr_info that we are not interested
// in.
COMPILER_CHECK(sizeof(__sanitizer_dl_phdr_info) <= sizeof(dl_phdr_info));
CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_addr);
CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_name);
CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_phdr);
CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_phnum);
#endif // SANITIZER_LINUX || SANITIZER_FREEBSD
#if SANITIZER_GLIBC || SANITIZER_FREEBSD
CHECK_TYPE_SIZE(glob_t);
CHECK_SIZE_AND_OFFSET(glob_t, gl_pathc);
CHECK_SIZE_AND_OFFSET(glob_t, gl_pathv);
CHECK_SIZE_AND_OFFSET(glob_t, gl_offs);
CHECK_SIZE_AND_OFFSET(glob_t, gl_flags);
CHECK_SIZE_AND_OFFSET(glob_t, gl_closedir);
CHECK_SIZE_AND_OFFSET(glob_t, gl_readdir);
CHECK_SIZE_AND_OFFSET(glob_t, gl_opendir);
CHECK_SIZE_AND_OFFSET(glob_t, gl_lstat);
CHECK_SIZE_AND_OFFSET(glob_t, gl_stat);
#endif // SANITIZER_GLIBC || SANITIZER_FREEBSD
CHECK_TYPE_SIZE(addrinfo);
CHECK_SIZE_AND_OFFSET(addrinfo, ai_flags);
CHECK_SIZE_AND_OFFSET(addrinfo, ai_family);
CHECK_SIZE_AND_OFFSET(addrinfo, ai_socktype);
CHECK_SIZE_AND_OFFSET(addrinfo, ai_protocol);
CHECK_SIZE_AND_OFFSET(addrinfo, ai_protocol);
CHECK_SIZE_AND_OFFSET(addrinfo, ai_addrlen);
CHECK_SIZE_AND_OFFSET(addrinfo, ai_canonname);
CHECK_SIZE_AND_OFFSET(addrinfo, ai_addr);
CHECK_TYPE_SIZE(hostent);
CHECK_SIZE_AND_OFFSET(hostent, h_name);
CHECK_SIZE_AND_OFFSET(hostent, h_aliases);
CHECK_SIZE_AND_OFFSET(hostent, h_addrtype);
CHECK_SIZE_AND_OFFSET(hostent, h_length);
CHECK_SIZE_AND_OFFSET(hostent, h_addr_list);
CHECK_TYPE_SIZE(iovec);
CHECK_SIZE_AND_OFFSET(iovec, iov_base);
CHECK_SIZE_AND_OFFSET(iovec, iov_len);
// In POSIX, int msg_iovlen; socklen_t msg_controllen; socklen_t cmsg_len; but
// many implementations don't conform to the standard. Since we pick the
// non-conforming glibc definition, exclude the checks for musl (incompatible
// sizes but compatible offsets).
CHECK_TYPE_SIZE(msghdr);
CHECK_SIZE_AND_OFFSET(msghdr, msg_name);
CHECK_SIZE_AND_OFFSET(msghdr, msg_namelen);
CHECK_SIZE_AND_OFFSET(msghdr, msg_iov);
#if SANITIZER_GLIBC || SANITIZER_ANDROID
CHECK_SIZE_AND_OFFSET(msghdr, msg_iovlen);
#endif
CHECK_SIZE_AND_OFFSET(msghdr, msg_control);
#if SANITIZER_GLIBC || SANITIZER_ANDROID
CHECK_SIZE_AND_OFFSET(msghdr, msg_controllen);
#endif
CHECK_SIZE_AND_OFFSET(msghdr, msg_flags);
CHECK_TYPE_SIZE(cmsghdr);
#if SANITIZER_GLIBC || SANITIZER_ANDROID
CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_len);
#endif
CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_level);
CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_type);
#if SANITIZER_LINUX && (__ANDROID_API__ >= 21 || __GLIBC_PREREQ (2, 14))
CHECK_TYPE_SIZE(mmsghdr);
CHECK_SIZE_AND_OFFSET(mmsghdr, msg_hdr);
CHECK_SIZE_AND_OFFSET(mmsghdr, msg_len);
#endif
COMPILER_CHECK(sizeof(__sanitizer_dirent) <= sizeof(dirent));
CHECK_SIZE_AND_OFFSET(dirent, d_ino);
#if SANITIZER_MAC
CHECK_SIZE_AND_OFFSET(dirent, d_seekoff);
#elif SANITIZER_FREEBSD
// There is no 'd_off' field on FreeBSD.
#else
CHECK_SIZE_AND_OFFSET(dirent, d_off);
#endif
CHECK_SIZE_AND_OFFSET(dirent, d_reclen);
#if SANITIZER_LINUX && !SANITIZER_ANDROID
COMPILER_CHECK(sizeof(__sanitizer_dirent64) <= sizeof(dirent64));
CHECK_SIZE_AND_OFFSET(dirent64, d_ino);
CHECK_SIZE_AND_OFFSET(dirent64, d_off);
CHECK_SIZE_AND_OFFSET(dirent64, d_reclen);
#endif
CHECK_TYPE_SIZE(ifconf);
CHECK_SIZE_AND_OFFSET(ifconf, ifc_len);
CHECK_SIZE_AND_OFFSET(ifconf, ifc_ifcu);
CHECK_TYPE_SIZE(pollfd);
CHECK_SIZE_AND_OFFSET(pollfd, fd);
CHECK_SIZE_AND_OFFSET(pollfd, events);
CHECK_SIZE_AND_OFFSET(pollfd, revents);
CHECK_TYPE_SIZE(nfds_t);
CHECK_TYPE_SIZE(sigset_t);
COMPILER_CHECK(sizeof(__sanitizer_sigaction) == sizeof(struct sigaction));
// Can't write checks for sa_handler and sa_sigaction due to them being
// preprocessor macros.
CHECK_STRUCT_SIZE_AND_OFFSET(sigaction, sa_mask);
#if !defined(__s390x__) || __GLIBC_PREREQ (2, 20)
// On s390x glibc 2.19 and earlier sa_flags was unsigned long, and sa_resv
// didn't exist.
CHECK_STRUCT_SIZE_AND_OFFSET(sigaction, sa_flags);
#endif
#if SANITIZER_LINUX && (!SANITIZER_ANDROID || !SANITIZER_MIPS32)
CHECK_STRUCT_SIZE_AND_OFFSET(sigaction, sa_restorer);
#endif
#if SANITIZER_LINUX
CHECK_TYPE_SIZE(__sysctl_args);
CHECK_SIZE_AND_OFFSET(__sysctl_args, name);
CHECK_SIZE_AND_OFFSET(__sysctl_args, nlen);
CHECK_SIZE_AND_OFFSET(__sysctl_args, oldval);
CHECK_SIZE_AND_OFFSET(__sysctl_args, oldlenp);
CHECK_SIZE_AND_OFFSET(__sysctl_args, newval);
CHECK_SIZE_AND_OFFSET(__sysctl_args, newlen);
CHECK_TYPE_SIZE(__kernel_uid_t);
CHECK_TYPE_SIZE(__kernel_gid_t);
#if SANITIZER_USES_UID16_SYSCALLS
CHECK_TYPE_SIZE(__kernel_old_uid_t);
CHECK_TYPE_SIZE(__kernel_old_gid_t);
#endif
CHECK_TYPE_SIZE(__kernel_off_t);
CHECK_TYPE_SIZE(__kernel_loff_t);
CHECK_TYPE_SIZE(__kernel_fd_set);
#endif
#if !SANITIZER_ANDROID
CHECK_TYPE_SIZE(wordexp_t);
CHECK_SIZE_AND_OFFSET(wordexp_t, we_wordc);
CHECK_SIZE_AND_OFFSET(wordexp_t, we_wordv);
CHECK_SIZE_AND_OFFSET(wordexp_t, we_offs);
#endif
CHECK_TYPE_SIZE(tm);
CHECK_SIZE_AND_OFFSET(tm, tm_sec);
CHECK_SIZE_AND_OFFSET(tm, tm_min);
CHECK_SIZE_AND_OFFSET(tm, tm_hour);
CHECK_SIZE_AND_OFFSET(tm, tm_mday);
CHECK_SIZE_AND_OFFSET(tm, tm_mon);
CHECK_SIZE_AND_OFFSET(tm, tm_year);
CHECK_SIZE_AND_OFFSET(tm, tm_wday);
CHECK_SIZE_AND_OFFSET(tm, tm_yday);
CHECK_SIZE_AND_OFFSET(tm, tm_isdst);
CHECK_SIZE_AND_OFFSET(tm, tm_gmtoff);
CHECK_SIZE_AND_OFFSET(tm, tm_zone);
#if SANITIZER_LINUX
CHECK_TYPE_SIZE(mntent);
CHECK_SIZE_AND_OFFSET(mntent, mnt_fsname);
CHECK_SIZE_AND_OFFSET(mntent, mnt_dir);
CHECK_SIZE_AND_OFFSET(mntent, mnt_type);
CHECK_SIZE_AND_OFFSET(mntent, mnt_opts);
CHECK_SIZE_AND_OFFSET(mntent, mnt_freq);
CHECK_SIZE_AND_OFFSET(mntent, mnt_passno);
#endif
CHECK_TYPE_SIZE(ether_addr);
#if SANITIZER_GLIBC || SANITIZER_FREEBSD
CHECK_TYPE_SIZE(ipc_perm);
# if SANITIZER_FREEBSD
CHECK_SIZE_AND_OFFSET(ipc_perm, key);
CHECK_SIZE_AND_OFFSET(ipc_perm, seq);
# else
CHECK_SIZE_AND_OFFSET(ipc_perm, __key);
CHECK_SIZE_AND_OFFSET(ipc_perm, __seq);
# endif
CHECK_SIZE_AND_OFFSET(ipc_perm, uid);
CHECK_SIZE_AND_OFFSET(ipc_perm, gid);
CHECK_SIZE_AND_OFFSET(ipc_perm, cuid);
CHECK_SIZE_AND_OFFSET(ipc_perm, cgid);
#if !SANITIZER_LINUX || __GLIBC_PREREQ (2, 31)
/* glibc 2.30 and earlier provided 16-bit mode field instead of 32-bit
on many architectures. */
CHECK_SIZE_AND_OFFSET(ipc_perm, mode);
#endif
CHECK_TYPE_SIZE(shmid_ds);
CHECK_SIZE_AND_OFFSET(shmid_ds, shm_perm);
CHECK_SIZE_AND_OFFSET(shmid_ds, shm_segsz);
CHECK_SIZE_AND_OFFSET(shmid_ds, shm_atime);
CHECK_SIZE_AND_OFFSET(shmid_ds, shm_dtime);
CHECK_SIZE_AND_OFFSET(shmid_ds, shm_ctime);
CHECK_SIZE_AND_OFFSET(shmid_ds, shm_cpid);
CHECK_SIZE_AND_OFFSET(shmid_ds, shm_lpid);
CHECK_SIZE_AND_OFFSET(shmid_ds, shm_nattch);
#endif
CHECK_TYPE_SIZE(clock_t);
#if SANITIZER_LINUX
CHECK_TYPE_SIZE(clockid_t);
#endif
#if !SANITIZER_ANDROID
CHECK_TYPE_SIZE(ifaddrs);
CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_next);
CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_name);
CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_addr);
CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_netmask);
#if SANITIZER_LINUX || SANITIZER_FREEBSD
// Compare against the union, because we can't reach into the union in a
// compliant way.
#ifdef ifa_dstaddr
#undef ifa_dstaddr
#endif
# if SANITIZER_FREEBSD
CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_dstaddr);
# else
COMPILER_CHECK(sizeof(((__sanitizer_ifaddrs *)nullptr)->ifa_dstaddr) ==
sizeof(((ifaddrs *)nullptr)->ifa_ifu));
COMPILER_CHECK(offsetof(__sanitizer_ifaddrs, ifa_dstaddr) ==
offsetof(ifaddrs, ifa_ifu));
# endif // SANITIZER_FREEBSD
#else
CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_dstaddr);
#endif // SANITIZER_LINUX
CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_data);
#endif
#if SANITIZER_GLIBC || SANITIZER_ANDROID
COMPILER_CHECK(sizeof(__sanitizer_struct_mallinfo) == sizeof(struct mallinfo));
#endif
#if !SANITIZER_ANDROID
CHECK_TYPE_SIZE(timeb);
CHECK_SIZE_AND_OFFSET(timeb, time);
CHECK_SIZE_AND_OFFSET(timeb, millitm);
CHECK_SIZE_AND_OFFSET(timeb, timezone);
CHECK_SIZE_AND_OFFSET(timeb, dstflag);
#endif
CHECK_TYPE_SIZE(passwd);
CHECK_SIZE_AND_OFFSET(passwd, pw_name);
CHECK_SIZE_AND_OFFSET(passwd, pw_passwd);
CHECK_SIZE_AND_OFFSET(passwd, pw_uid);
CHECK_SIZE_AND_OFFSET(passwd, pw_gid);
CHECK_SIZE_AND_OFFSET(passwd, pw_dir);
CHECK_SIZE_AND_OFFSET(passwd, pw_shell);
#if !SANITIZER_ANDROID
CHECK_SIZE_AND_OFFSET(passwd, pw_gecos);
#endif
#if SANITIZER_MAC
CHECK_SIZE_AND_OFFSET(passwd, pw_change);
CHECK_SIZE_AND_OFFSET(passwd, pw_expire);
CHECK_SIZE_AND_OFFSET(passwd, pw_class);
#endif
CHECK_TYPE_SIZE(group);
CHECK_SIZE_AND_OFFSET(group, gr_name);
CHECK_SIZE_AND_OFFSET(group, gr_passwd);
CHECK_SIZE_AND_OFFSET(group, gr_gid);
CHECK_SIZE_AND_OFFSET(group, gr_mem);
#if HAVE_RPC_XDR_H
CHECK_TYPE_SIZE(XDR);
CHECK_SIZE_AND_OFFSET(XDR, x_op);
CHECK_SIZE_AND_OFFSET(XDR, x_ops);
CHECK_SIZE_AND_OFFSET(XDR, x_public);
CHECK_SIZE_AND_OFFSET(XDR, x_private);
CHECK_SIZE_AND_OFFSET(XDR, x_base);
CHECK_SIZE_AND_OFFSET(XDR, x_handy);
COMPILER_CHECK(__sanitizer_XDR_ENCODE == XDR_ENCODE);
COMPILER_CHECK(__sanitizer_XDR_DECODE == XDR_DECODE);
COMPILER_CHECK(__sanitizer_XDR_FREE == XDR_FREE);
#endif
#if SANITIZER_GLIBC
COMPILER_CHECK(sizeof(__sanitizer_FILE) <= sizeof(FILE));
CHECK_SIZE_AND_OFFSET(FILE, _flags);
CHECK_SIZE_AND_OFFSET(FILE, _IO_read_ptr);
CHECK_SIZE_AND_OFFSET(FILE, _IO_read_end);
CHECK_SIZE_AND_OFFSET(FILE, _IO_read_base);
CHECK_SIZE_AND_OFFSET(FILE, _IO_write_ptr);
CHECK_SIZE_AND_OFFSET(FILE, _IO_write_end);
CHECK_SIZE_AND_OFFSET(FILE, _IO_write_base);
CHECK_SIZE_AND_OFFSET(FILE, _IO_buf_base);
CHECK_SIZE_AND_OFFSET(FILE, _IO_buf_end);
CHECK_SIZE_AND_OFFSET(FILE, _IO_save_base);
CHECK_SIZE_AND_OFFSET(FILE, _IO_backup_base);
CHECK_SIZE_AND_OFFSET(FILE, _IO_save_end);
CHECK_SIZE_AND_OFFSET(FILE, _markers);
CHECK_SIZE_AND_OFFSET(FILE, _chain);
CHECK_SIZE_AND_OFFSET(FILE, _fileno);
COMPILER_CHECK(sizeof(__sanitizer__obstack_chunk) <= sizeof(_obstack_chunk));
CHECK_SIZE_AND_OFFSET(_obstack_chunk, limit);
CHECK_SIZE_AND_OFFSET(_obstack_chunk, prev);
CHECK_TYPE_SIZE(obstack);
CHECK_SIZE_AND_OFFSET(obstack, chunk_size);
CHECK_SIZE_AND_OFFSET(obstack, chunk);
CHECK_SIZE_AND_OFFSET(obstack, object_base);
CHECK_SIZE_AND_OFFSET(obstack, next_free);
CHECK_TYPE_SIZE(cookie_io_functions_t);
CHECK_SIZE_AND_OFFSET(cookie_io_functions_t, read);
CHECK_SIZE_AND_OFFSET(cookie_io_functions_t, write);
CHECK_SIZE_AND_OFFSET(cookie_io_functions_t, seek);
CHECK_SIZE_AND_OFFSET(cookie_io_functions_t, close);
#endif // SANITIZER_GLIBC
#if SANITIZER_LINUX || SANITIZER_FREEBSD
CHECK_TYPE_SIZE(sem_t);
#endif
#if SANITIZER_LINUX && defined(__arm__)
COMPILER_CHECK(ARM_VFPREGS_SIZE == ARM_VFPREGS_SIZE_ASAN);
#endif
#endif // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_MAC
diff --git a/contrib/llvm-project/libcxx/include/__algorithm/in_in_out_result.h b/contrib/llvm-project/libcxx/include/__algorithm/in_in_out_result.h
index e365eb58eb62..a492d2735229 100644
--- a/contrib/llvm-project/libcxx/include/__algorithm/in_in_out_result.h
+++ b/contrib/llvm-project/libcxx/include/__algorithm/in_in_out_result.h
@@ -1,48 +1,54 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___ALGORITHM_IN_IN_OUT_RESULT_H
#define _LIBCPP___ALGORITHM_IN_IN_OUT_RESULT_H
#include <__concepts/convertible_to.h>
#include <__config>
#include <__utility/move.h>
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
_LIBCPP_BEGIN_NAMESPACE_STD
-#ifndef _LIBCPP_HAS_NO_CONCEPTS
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
namespace ranges {
+
template <class _I1, class _I2, class _O1>
struct in_in_out_result {
[[no_unique_address]] _I1 in1;
[[no_unique_address]] _I2 in2;
[[no_unique_address]] _O1 out;
template <class _II1, class _II2, class _OO1>
requires convertible_to<const _I1&, _II1> && convertible_to<const _I2&, _II2> && convertible_to<const _O1&, _OO1>
_LIBCPP_HIDE_FROM_ABI constexpr
operator in_in_out_result<_II1, _II2, _OO1>() const& {
return {in1, in2, out};
}
template <class _II1, class _II2, class _OO1>
requires convertible_to<_I1, _II1> && convertible_to<_I2, _II2> && convertible_to<_O1, _OO1>
_LIBCPP_HIDE_FROM_ABI constexpr
operator in_in_out_result<_II1, _II2, _OO1>() && {
return {_VSTD::move(in1), _VSTD::move(in2), _VSTD::move(out)};
}
};
+
} // namespace ranges
-#endif // _LIBCPP_HAS_NO_CONCEPTS
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
-#endif // _LIBCPP___ALGORITHM_IN_IN_RESULT_H
+#endif // _LIBCPP___ALGORITHM_IN_IN_OUT_RESULT_H
diff --git a/contrib/llvm-project/libcxx/include/__algorithm/in_in_result.h b/contrib/llvm-project/libcxx/include/__algorithm/in_in_result.h
index ed14ecedbbdf..c8fe43d039dc 100644
--- a/contrib/llvm-project/libcxx/include/__algorithm/in_in_result.h
+++ b/contrib/llvm-project/libcxx/include/__algorithm/in_in_result.h
@@ -1,45 +1,51 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___ALGORITHM_IN_IN_RESULT_H
#define _LIBCPP___ALGORITHM_IN_IN_RESULT_H
#include <__concepts/convertible_to.h>
#include <__config>
#include <__utility/move.h>
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
_LIBCPP_BEGIN_NAMESPACE_STD
-#ifndef _LIBCPP_HAS_NO_CONCEPTS
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
namespace ranges {
+
template <class _I1, class _I2>
struct in_in_result {
[[no_unique_address]] _I1 in1;
[[no_unique_address]] _I2 in2;
template <class _II1, class _II2>
requires convertible_to<const _I1&, _II1> && convertible_to<const _I2&, _II2>
_LIBCPP_HIDE_FROM_ABI constexpr
operator in_in_result<_II1, _II2>() const & {
return {in1, in2};
}
template <class _II1, class _II2>
requires convertible_to<_I1, _II1> && convertible_to<_I2, _II2>
_LIBCPP_HIDE_FROM_ABI constexpr
operator in_in_result<_II1, _II2>() && { return {_VSTD::move(in1), _VSTD::move(in2)}; }
};
+
} // namespace ranges
-#endif // _LIBCPP_HAS_NO_CONCEPTS
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_IN_IN_RESULT_H
diff --git a/contrib/llvm-project/libcxx/include/__algorithm/in_out_result.h b/contrib/llvm-project/libcxx/include/__algorithm/in_out_result.h
index 8a58d6ada10c..d3c16e4acd45 100644
--- a/contrib/llvm-project/libcxx/include/__algorithm/in_out_result.h
+++ b/contrib/llvm-project/libcxx/include/__algorithm/in_out_result.h
@@ -1,52 +1,54 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___ALGORITHM_IN_OUT_RESULT_H
#define _LIBCPP___ALGORITHM_IN_OUT_RESULT_H
#include <__concepts/convertible_to.h>
#include <__config>
#include <__utility/move.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
namespace ranges {
template<class _InputIterator, class _OutputIterator>
struct in_out_result {
[[no_unique_address]] _InputIterator in;
[[no_unique_address]] _OutputIterator out;
template <class _InputIterator2, class _OutputIterator2>
requires convertible_to<const _InputIterator&, _InputIterator2> && convertible_to<const _OutputIterator&,
_OutputIterator2>
_LIBCPP_HIDE_FROM_ABI
constexpr operator in_out_result<_InputIterator2, _OutputIterator2>() const & {
return {in, out};
}
template <class _InputIterator2, class _OutputIterator2>
requires convertible_to<_InputIterator, _InputIterator2> && convertible_to<_OutputIterator, _OutputIterator2>
_LIBCPP_HIDE_FROM_ABI
constexpr operator in_out_result<_InputIterator2, _OutputIterator2>() && {
return {_VSTD::move(in), _VSTD::move(out)};
}
};
} // namespace ranges
+
#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_IN_OUT_RESULT_H
diff --git a/contrib/llvm-project/libcxx/include/__chrono/duration.h b/contrib/llvm-project/libcxx/include/__chrono/duration.h
index 24801772ec5d..b7d88cb52ea8 100644
--- a/contrib/llvm-project/libcxx/include/__chrono/duration.h
+++ b/contrib/llvm-project/libcxx/include/__chrono/duration.h
@@ -1,615 +1,615 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CHRONO_DURATION_H
#define _LIBCPP___CHRONO_DURATION_H
#include <__config>
#include <limits>
#include <ratio>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_PUSH_MACROS
#include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD
namespace chrono
{
template <class _Rep, class _Period = ratio<1> > class _LIBCPP_TEMPLATE_VIS duration;
template <class _Tp>
struct __is_duration : false_type {};
template <class _Rep, class _Period>
struct __is_duration<duration<_Rep, _Period> > : true_type {};
template <class _Rep, class _Period>
struct __is_duration<const duration<_Rep, _Period> > : true_type {};
template <class _Rep, class _Period>
struct __is_duration<volatile duration<_Rep, _Period> > : true_type {};
template <class _Rep, class _Period>
struct __is_duration<const volatile duration<_Rep, _Period> > : true_type {};
} // namespace chrono
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
struct _LIBCPP_TEMPLATE_VIS common_type<chrono::duration<_Rep1, _Period1>,
chrono::duration<_Rep2, _Period2> >
{
typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
typename __ratio_gcd<_Period1, _Period2>::type> type;
};
namespace chrono {
// duration_cast
template <class _FromDuration, class _ToDuration,
class _Period = typename ratio_divide<typename _FromDuration::period, typename _ToDuration::period>::type,
bool = _Period::num == 1,
bool = _Period::den == 1>
struct __duration_cast;
template <class _FromDuration, class _ToDuration, class _Period>
struct __duration_cast<_FromDuration, _ToDuration, _Period, true, true>
{
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
_ToDuration operator()(const _FromDuration& __fd) const
{
return _ToDuration(static_cast<typename _ToDuration::rep>(__fd.count()));
}
};
template <class _FromDuration, class _ToDuration, class _Period>
struct __duration_cast<_FromDuration, _ToDuration, _Period, true, false>
{
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
_ToDuration operator()(const _FromDuration& __fd) const
{
typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
return _ToDuration(static_cast<typename _ToDuration::rep>(
static_cast<_Ct>(__fd.count()) / static_cast<_Ct>(_Period::den)));
}
};
template <class _FromDuration, class _ToDuration, class _Period>
struct __duration_cast<_FromDuration, _ToDuration, _Period, false, true>
{
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
_ToDuration operator()(const _FromDuration& __fd) const
{
typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
return _ToDuration(static_cast<typename _ToDuration::rep>(
static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)));
}
};
template <class _FromDuration, class _ToDuration, class _Period>
struct __duration_cast<_FromDuration, _ToDuration, _Period, false, false>
{
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
_ToDuration operator()(const _FromDuration& __fd) const
{
typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
return _ToDuration(static_cast<typename _ToDuration::rep>(
static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)
/ static_cast<_Ct>(_Period::den)));
}
};
template <class _ToDuration, class _Rep, class _Period>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
typename enable_if
<
__is_duration<_ToDuration>::value,
_ToDuration
>::type
duration_cast(const duration<_Rep, _Period>& __fd)
{
return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd);
}
template <class _Rep>
struct _LIBCPP_TEMPLATE_VIS treat_as_floating_point : is_floating_point<_Rep> {};
#if _LIBCPP_STD_VER > 14
template <class _Rep>
inline constexpr bool treat_as_floating_point_v = treat_as_floating_point<_Rep>::value;
#endif
template <class _Rep>
struct _LIBCPP_TEMPLATE_VIS duration_values
{
public:
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() _NOEXCEPT {return _Rep(0);}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max() _NOEXCEPT {return numeric_limits<_Rep>::max();}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min() _NOEXCEPT {return numeric_limits<_Rep>::lowest();}
};
#if _LIBCPP_STD_VER > 14
template <class _ToDuration, class _Rep, class _Period>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
typename enable_if
<
__is_duration<_ToDuration>::value,
_ToDuration
>::type
floor(const duration<_Rep, _Period>& __d)
{
_ToDuration __t = duration_cast<_ToDuration>(__d);
if (__t > __d)
__t = __t - _ToDuration{1};
return __t;
}
template <class _ToDuration, class _Rep, class _Period>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
typename enable_if
<
__is_duration<_ToDuration>::value,
_ToDuration
>::type
ceil(const duration<_Rep, _Period>& __d)
{
_ToDuration __t = duration_cast<_ToDuration>(__d);
if (__t < __d)
__t = __t + _ToDuration{1};
return __t;
}
template <class _ToDuration, class _Rep, class _Period>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
typename enable_if
<
__is_duration<_ToDuration>::value,
_ToDuration
>::type
round(const duration<_Rep, _Period>& __d)
{
_ToDuration __lower = floor<_ToDuration>(__d);
_ToDuration __upper = __lower + _ToDuration{1};
auto __lowerDiff = __d - __lower;
auto __upperDiff = __upper - __d;
if (__lowerDiff < __upperDiff)
return __lower;
if (__lowerDiff > __upperDiff)
return __upper;
return __lower.count() & 1 ? __upper : __lower;
}
#endif
// duration
template <class _Rep, class _Period>
class _LIBCPP_TEMPLATE_VIS duration
{
static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration");
static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio");
static_assert(_Period::num > 0, "duration period must be positive");
template <class _R1, class _R2>
struct __no_overflow
{
private:
static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
static const intmax_t __n1 = _R1::num / __gcd_n1_n2;
static const intmax_t __d1 = _R1::den / __gcd_d1_d2;
static const intmax_t __n2 = _R2::num / __gcd_n1_n2;
static const intmax_t __d2 = _R2::den / __gcd_d1_d2;
static const intmax_t max = -((intmax_t(1) << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1);
template <intmax_t _Xp, intmax_t _Yp, bool __overflow>
struct __mul // __overflow == false
{
static const intmax_t value = _Xp * _Yp;
};
template <intmax_t _Xp, intmax_t _Yp>
struct __mul<_Xp, _Yp, true>
{
static const intmax_t value = 1;
};
public:
static const bool value = (__n1 <= max / __d2) && (__n2 <= max / __d1);
typedef ratio<__mul<__n1, __d2, !value>::value,
__mul<__n2, __d1, !value>::value> type;
};
public:
typedef _Rep rep;
typedef typename _Period::type period;
private:
rep __rep_;
public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
#ifndef _LIBCPP_CXX03_LANG
duration() = default;
#else
duration() {}
#endif
template <class _Rep2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
explicit duration(const _Rep2& __r,
typename enable_if
<
- is_convertible<_Rep2, rep>::value &&
+ is_convertible<const _Rep2&, rep>::value &&
(treat_as_floating_point<rep>::value ||
!treat_as_floating_point<_Rep2>::value)
>::type* = nullptr)
: __rep_(__r) {}
// conversions
template <class _Rep2, class _Period2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
duration(const duration<_Rep2, _Period2>& __d,
typename enable_if
<
__no_overflow<_Period2, period>::value && (
treat_as_floating_point<rep>::value ||
(__no_overflow<_Period2, period>::type::den == 1 &&
!treat_as_floating_point<_Rep2>::value))
>::type* = nullptr)
: __rep_(chrono::duration_cast<duration>(__d).count()) {}
// observer
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR rep count() const {return __rep_;}
// arithmetic
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator++() {++__rep_; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration operator++(int) {return duration(__rep_++);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator--() {--__rep_; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration operator--(int) {return duration(__rep_--);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator*=(const rep& rhs) {__rep_ *= rhs; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator/=(const rep& rhs) {__rep_ /= rhs; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const rep& rhs) {__rep_ %= rhs; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const duration& rhs) {__rep_ %= rhs.count(); return *this;}
// special values
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration zero() _NOEXCEPT {return duration(duration_values<rep>::zero());}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min() _NOEXCEPT {return duration(duration_values<rep>::min());}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max() _NOEXCEPT {return duration(duration_values<rep>::max());}
};
typedef duration<long long, nano> nanoseconds;
typedef duration<long long, micro> microseconds;
typedef duration<long long, milli> milliseconds;
typedef duration<long long > seconds;
typedef duration< long, ratio< 60> > minutes;
typedef duration< long, ratio<3600> > hours;
#if _LIBCPP_STD_VER > 17
typedef duration< int, ratio_multiply<ratio<24>, hours::period>> days;
typedef duration< int, ratio_multiply<ratio<7>, days::period>> weeks;
typedef duration< int, ratio_multiply<ratio<146097, 400>, days::period>> years;
typedef duration< int, ratio_divide<years::period, ratio<12>>> months;
#endif
// Duration ==
template <class _LhsDuration, class _RhsDuration>
struct __duration_eq
{
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const
{
typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
return _Ct(__lhs).count() == _Ct(__rhs).count();
}
};
template <class _LhsDuration>
struct __duration_eq<_LhsDuration, _LhsDuration>
{
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const
{return __lhs.count() == __rhs.count();}
};
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
bool
operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
{
return __duration_eq<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
}
// Duration !=
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
bool
operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
{
return !(__lhs == __rhs);
}
// Duration <
template <class _LhsDuration, class _RhsDuration>
struct __duration_lt
{
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const
{
typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
return _Ct(__lhs).count() < _Ct(__rhs).count();
}
};
template <class _LhsDuration>
struct __duration_lt<_LhsDuration, _LhsDuration>
{
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const
{return __lhs.count() < __rhs.count();}
};
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
bool
operator< (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
{
return __duration_lt<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
}
// Duration >
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
bool
operator> (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
{
return __rhs < __lhs;
}
// Duration <=
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
bool
operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
{
return !(__rhs < __lhs);
}
// Duration >=
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
bool
operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
{
return !(__lhs < __rhs);
}
// Duration +
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
{
typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
return _Cd(_Cd(__lhs).count() + _Cd(__rhs).count());
}
// Duration -
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
{
typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
return _Cd(_Cd(__lhs).count() - _Cd(__rhs).count());
}
// Duration *
template <class _Rep1, class _Period, class _Rep2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
typename enable_if
<
is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value,
duration<typename common_type<_Rep1, _Rep2>::type, _Period>
>::type
operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
{
typedef typename common_type<_Rep1, _Rep2>::type _Cr;
typedef duration<_Cr, _Period> _Cd;
return _Cd(_Cd(__d).count() * static_cast<_Cr>(__s));
}
template <class _Rep1, class _Period, class _Rep2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
typename enable_if
<
is_convertible<_Rep1, typename common_type<_Rep1, _Rep2>::type>::value,
duration<typename common_type<_Rep1, _Rep2>::type, _Period>
>::type
operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
{
return __d * __s;
}
// Duration /
template <class _Rep1, class _Period, class _Rep2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
typename enable_if
<
!__is_duration<_Rep2>::value &&
is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value,
duration<typename common_type<_Rep1, _Rep2>::type, _Period>
>::type
operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
{
typedef typename common_type<_Rep1, _Rep2>::type _Cr;
typedef duration<_Cr, _Period> _Cd;
return _Cd(_Cd(__d).count() / static_cast<_Cr>(__s));
}
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
typename common_type<_Rep1, _Rep2>::type
operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
{
typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Ct;
return _Ct(__lhs).count() / _Ct(__rhs).count();
}
// Duration %
template <class _Rep1, class _Period, class _Rep2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
typename enable_if
<
!__is_duration<_Rep2>::value &&
is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value,
duration<typename common_type<_Rep1, _Rep2>::type, _Period>
>::type
operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
{
typedef typename common_type<_Rep1, _Rep2>::type _Cr;
typedef duration<_Cr, _Period> _Cd;
return _Cd(_Cd(__d).count() % static_cast<_Cr>(__s));
}
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
{
typedef typename common_type<_Rep1, _Rep2>::type _Cr;
typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
return _Cd(static_cast<_Cr>(_Cd(__lhs).count()) % static_cast<_Cr>(_Cd(__rhs).count()));
}
} // namespace chrono
#if _LIBCPP_STD_VER > 11
// Suffixes for duration literals [time.duration.literals]
inline namespace literals
{
inline namespace chrono_literals
{
constexpr chrono::hours operator""h(unsigned long long __h)
{
return chrono::hours(static_cast<chrono::hours::rep>(__h));
}
constexpr chrono::duration<long double, ratio<3600,1>> operator""h(long double __h)
{
return chrono::duration<long double, ratio<3600,1>>(__h);
}
constexpr chrono::minutes operator""min(unsigned long long __m)
{
return chrono::minutes(static_cast<chrono::minutes::rep>(__m));
}
constexpr chrono::duration<long double, ratio<60,1>> operator""min(long double __m)
{
return chrono::duration<long double, ratio<60,1>> (__m);
}
constexpr chrono::seconds operator""s(unsigned long long __s)
{
return chrono::seconds(static_cast<chrono::seconds::rep>(__s));
}
constexpr chrono::duration<long double> operator""s(long double __s)
{
return chrono::duration<long double> (__s);
}
constexpr chrono::milliseconds operator""ms(unsigned long long __ms)
{
return chrono::milliseconds(static_cast<chrono::milliseconds::rep>(__ms));
}
constexpr chrono::duration<long double, milli> operator""ms(long double __ms)
{
return chrono::duration<long double, milli>(__ms);
}
constexpr chrono::microseconds operator""us(unsigned long long __us)
{
return chrono::microseconds(static_cast<chrono::microseconds::rep>(__us));
}
constexpr chrono::duration<long double, micro> operator""us(long double __us)
{
return chrono::duration<long double, micro> (__us);
}
constexpr chrono::nanoseconds operator""ns(unsigned long long __ns)
{
return chrono::nanoseconds(static_cast<chrono::nanoseconds::rep>(__ns));
}
constexpr chrono::duration<long double, nano> operator""ns(long double __ns)
{
return chrono::duration<long double, nano> (__ns);
}
} // namespace chrono_literals
} // namespace literals
namespace chrono { // hoist the literals into namespace std::chrono
using namespace literals::chrono_literals;
} // namespace chrono
#endif // _LIBCPP_STD_VER > 11
_LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS
#endif // _LIBCPP___CHRONO_DURATION_H
diff --git a/contrib/llvm-project/libcxx/include/__compare/compare_partial_order_fallback.h b/contrib/llvm-project/libcxx/include/__compare/compare_partial_order_fallback.h
index 895523b38fb3..64937eaf37dd 100644
--- a/contrib/llvm-project/libcxx/include/__compare/compare_partial_order_fallback.h
+++ b/contrib/llvm-project/libcxx/include/__compare/compare_partial_order_fallback.h
@@ -1,73 +1,73 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___COMPARE_COMPARE_PARTIAL_ORDER_FALLBACK
#define _LIBCPP___COMPARE_COMPARE_PARTIAL_ORDER_FALLBACK
#include <__compare/ordering.h>
#include <__compare/partial_order.h>
#include <__config>
#include <__utility/forward.h>
#include <__utility/priority_tag.h>
#include <type_traits>
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [cmp.alg]
namespace __compare_partial_order_fallback {
struct __fn {
template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<1>)
noexcept(noexcept(_VSTD::partial_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
-> decltype( _VSTD::partial_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))
{ return _VSTD::partial_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)); }
template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<0>)
noexcept(noexcept(_VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u) ? partial_ordering::equivalent :
_VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u) ? partial_ordering::less :
_VSTD::forward<_Up>(__u) < _VSTD::forward<_Tp>(__t) ? partial_ordering::greater :
partial_ordering::unordered))
-> decltype( _VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u) ? partial_ordering::equivalent :
_VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u) ? partial_ordering::less :
_VSTD::forward<_Up>(__u) < _VSTD::forward<_Tp>(__t) ? partial_ordering::greater :
partial_ordering::unordered)
{
return _VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u) ? partial_ordering::equivalent :
_VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u) ? partial_ordering::less :
_VSTD::forward<_Up>(__u) < _VSTD::forward<_Tp>(__t) ? partial_ordering::greater :
partial_ordering::unordered;
}
template<class _Tp, class _Up>
_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>())))
-> decltype( __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()))
{ return __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()); }
};
} // namespace __compare_partial_order_fallback
inline namespace __cpo {
inline constexpr auto compare_partial_order_fallback = __compare_partial_order_fallback::__fn{};
} // namespace __cpo
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_COMPARE_PARTIAL_ORDER_FALLBACK
diff --git a/contrib/llvm-project/libcxx/include/__compare/compare_strong_order_fallback.h b/contrib/llvm-project/libcxx/include/__compare/compare_strong_order_fallback.h
index 5fee7b478068..b7abef26e9d2 100644
--- a/contrib/llvm-project/libcxx/include/__compare/compare_strong_order_fallback.h
+++ b/contrib/llvm-project/libcxx/include/__compare/compare_strong_order_fallback.h
@@ -1,70 +1,70 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___COMPARE_COMPARE_STRONG_ORDER_FALLBACK
#define _LIBCPP___COMPARE_COMPARE_STRONG_ORDER_FALLBACK
#include <__compare/ordering.h>
#include <__compare/strong_order.h>
#include <__config>
#include <__utility/forward.h>
#include <__utility/priority_tag.h>
#include <type_traits>
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [cmp.alg]
namespace __compare_strong_order_fallback {
struct __fn {
template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<1>)
noexcept(noexcept(_VSTD::strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
-> decltype( _VSTD::strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))
{ return _VSTD::strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)); }
template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<0>)
noexcept(noexcept(_VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u) ? strong_ordering::equal :
_VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u) ? strong_ordering::less :
strong_ordering::greater))
-> decltype( _VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u) ? strong_ordering::equal :
_VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u) ? strong_ordering::less :
strong_ordering::greater)
{
return _VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u) ? strong_ordering::equal :
_VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u) ? strong_ordering::less :
strong_ordering::greater;
}
template<class _Tp, class _Up>
_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>())))
-> decltype( __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()))
{ return __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()); }
};
} // namespace __compare_strong_order_fallback
inline namespace __cpo {
inline constexpr auto compare_strong_order_fallback = __compare_strong_order_fallback::__fn{};
} // namespace __cpo
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_COMPARE_STRONG_ORDER_FALLBACK
diff --git a/contrib/llvm-project/libcxx/include/__compare/compare_three_way.h b/contrib/llvm-project/libcxx/include/__compare/compare_three_way.h
index d7f339eda992..ddd37890a467 100644
--- a/contrib/llvm-project/libcxx/include/__compare/compare_three_way.h
+++ b/contrib/llvm-project/libcxx/include/__compare/compare_three_way.h
@@ -1,41 +1,41 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___COMPARE_COMPARE_THREE_WAY_H
#define _LIBCPP___COMPARE_COMPARE_THREE_WAY_H
#include <__compare/three_way_comparable.h>
#include <__config>
#include <__utility/forward.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
struct _LIBCPP_TEMPLATE_VIS compare_three_way
{
template<class _T1, class _T2>
requires three_way_comparable_with<_T1, _T2>
constexpr _LIBCPP_HIDE_FROM_ABI
auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) <=> _VSTD::forward<_T2>(__u)))
{ return _VSTD::forward<_T1>(__t) <=> _VSTD::forward<_T2>(__u); }
using is_transparent = void;
};
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_COMPARE_THREE_WAY_H
diff --git a/contrib/llvm-project/libcxx/include/__compare/compare_weak_order_fallback.h b/contrib/llvm-project/libcxx/include/__compare/compare_weak_order_fallback.h
index 0abd4f2dfbee..5a1807e69717 100644
--- a/contrib/llvm-project/libcxx/include/__compare/compare_weak_order_fallback.h
+++ b/contrib/llvm-project/libcxx/include/__compare/compare_weak_order_fallback.h
@@ -1,70 +1,70 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___COMPARE_COMPARE_WEAK_ORDER_FALLBACK
#define _LIBCPP___COMPARE_COMPARE_WEAK_ORDER_FALLBACK
#include <__compare/ordering.h>
#include <__compare/weak_order.h>
#include <__config>
#include <__utility/forward.h>
#include <__utility/priority_tag.h>
#include <type_traits>
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [cmp.alg]
namespace __compare_weak_order_fallback {
struct __fn {
template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<1>)
noexcept(noexcept(_VSTD::weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
-> decltype( _VSTD::weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))
{ return _VSTD::weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)); }
template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<0>)
noexcept(noexcept(_VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u) ? weak_ordering::equivalent :
_VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u) ? weak_ordering::less :
weak_ordering::greater))
-> decltype( _VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u) ? weak_ordering::equivalent :
_VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u) ? weak_ordering::less :
weak_ordering::greater)
{
return _VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u) ? weak_ordering::equivalent :
_VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u) ? weak_ordering::less :
weak_ordering::greater;
}
template<class _Tp, class _Up>
_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>())))
-> decltype( __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()))
{ return __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()); }
};
} // namespace __compare_weak_order_fallback
inline namespace __cpo {
inline constexpr auto compare_weak_order_fallback = __compare_weak_order_fallback::__fn{};
} // namespace __cpo
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_COMPARE_WEAK_ORDER_FALLBACK
diff --git a/contrib/llvm-project/libcxx/include/__compare/partial_order.h b/contrib/llvm-project/libcxx/include/__compare/partial_order.h
index ac8b405a4090..cbadfcde7396 100644
--- a/contrib/llvm-project/libcxx/include/__compare/partial_order.h
+++ b/contrib/llvm-project/libcxx/include/__compare/partial_order.h
@@ -1,71 +1,71 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___COMPARE_PARTIAL_ORDER
#define _LIBCPP___COMPARE_PARTIAL_ORDER
#include <__compare/compare_three_way.h>
#include <__compare/ordering.h>
#include <__compare/weak_order.h>
#include <__config>
#include <__utility/forward.h>
#include <__utility/priority_tag.h>
#include <type_traits>
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [cmp.alg]
namespace __partial_order {
struct __fn {
template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<2>)
noexcept(noexcept(partial_ordering(partial_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
-> decltype( partial_ordering(partial_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
{ return partial_ordering(partial_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<1>)
noexcept(noexcept(partial_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
-> decltype( partial_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
{ return partial_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<0>)
noexcept(noexcept(partial_ordering(_VSTD::weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
-> decltype( partial_ordering(_VSTD::weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
{ return partial_ordering(_VSTD::weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
template<class _Tp, class _Up>
_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>())))
-> decltype( __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>()))
{ return __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>()); }
};
} // namespace __partial_order
inline namespace __cpo {
inline constexpr auto partial_order = __partial_order::__fn{};
} // namespace __cpo
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_PARTIAL_ORDER
diff --git a/contrib/llvm-project/libcxx/include/__compare/strong_order.h b/contrib/llvm-project/libcxx/include/__compare/strong_order.h
index 42f060387d59..a0dc077047f5 100644
--- a/contrib/llvm-project/libcxx/include/__compare/strong_order.h
+++ b/contrib/llvm-project/libcxx/include/__compare/strong_order.h
@@ -1,136 +1,136 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___COMPARE_STRONG_ORDER
#define _LIBCPP___COMPARE_STRONG_ORDER
#include <__bit/bit_cast.h>
#include <__compare/compare_three_way.h>
#include <__compare/ordering.h>
#include <__config>
#include <__utility/forward.h>
#include <__utility/priority_tag.h>
#include <cmath>
#include <cstdint>
#include <limits>
#include <type_traits>
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
#pragma GCC system_header
#endif
_LIBCPP_PUSH_MACROS
#include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [cmp.alg]
namespace __strong_order {
struct __fn {
template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<2>)
noexcept(noexcept(strong_ordering(strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
-> decltype( strong_ordering(strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
{ return strong_ordering(strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
template<class _Tp, class _Up, class _Dp = decay_t<_Tp>>
requires is_same_v<_Dp, decay_t<_Up>> && is_floating_point_v<_Dp>
_LIBCPP_HIDE_FROM_ABI static constexpr strong_ordering
__go(_Tp&& __t, _Up&& __u, __priority_tag<1>) noexcept
{
if constexpr (numeric_limits<_Dp>::is_iec559 && sizeof(_Dp) == sizeof(int32_t)) {
int32_t __rx = _VSTD::bit_cast<int32_t>(__t);
int32_t __ry = _VSTD::bit_cast<int32_t>(__u);
__rx = (__rx < 0) ? (numeric_limits<int32_t>::min() - __rx - 1) : __rx;
__ry = (__ry < 0) ? (numeric_limits<int32_t>::min() - __ry - 1) : __ry;
return (__rx <=> __ry);
} else if constexpr (numeric_limits<_Dp>::is_iec559 && sizeof(_Dp) == sizeof(int64_t)) {
int64_t __rx = _VSTD::bit_cast<int64_t>(__t);
int64_t __ry = _VSTD::bit_cast<int64_t>(__u);
__rx = (__rx < 0) ? (numeric_limits<int64_t>::min() - __rx - 1) : __rx;
__ry = (__ry < 0) ? (numeric_limits<int64_t>::min() - __ry - 1) : __ry;
return (__rx <=> __ry);
} else if (__t < __u) {
return strong_ordering::less;
} else if (__t > __u) {
return strong_ordering::greater;
} else if (__t == __u) {
if constexpr (numeric_limits<_Dp>::radix == 2) {
return _VSTD::signbit(__u) <=> _VSTD::signbit(__t);
} else {
// This is bullet 3 of the IEEE754 algorithm, relevant
// only for decimal floating-point;
// see https://stackoverflow.com/questions/69068075/
if (__t == 0 || _VSTD::isinf(__t)) {
return _VSTD::signbit(__u) <=> _VSTD::signbit(__t);
} else {
int __texp, __uexp;
(void)_VSTD::frexp(__t, &__texp);
(void)_VSTD::frexp(__u, &__uexp);
return (__t < 0) ? (__texp <=> __uexp) : (__uexp <=> __texp);
}
}
} else {
// They're unordered, so one of them must be a NAN.
// The order is -QNAN, -SNAN, numbers, +SNAN, +QNAN.
bool __t_is_nan = _VSTD::isnan(__t);
bool __u_is_nan = _VSTD::isnan(__u);
bool __t_is_negative = _VSTD::signbit(__t);
bool __u_is_negative = _VSTD::signbit(__u);
using _IntType = conditional_t<
sizeof(__t) == sizeof(int32_t), int32_t, conditional_t<
sizeof(__t) == sizeof(int64_t), int64_t, void>
>;
if constexpr (is_same_v<_IntType, void>) {
static_assert(sizeof(_Dp) == 0, "std::strong_order is unimplemented for this floating-point type");
} else if (__t_is_nan && __u_is_nan) {
// Order by sign bit, then by "payload bits" (we'll just use bit_cast).
if (__t_is_negative != __u_is_negative) {
return (__u_is_negative <=> __t_is_negative);
} else {
return _VSTD::bit_cast<_IntType>(__t) <=> _VSTD::bit_cast<_IntType>(__u);
}
} else if (__t_is_nan) {
return __t_is_negative ? strong_ordering::less : strong_ordering::greater;
} else {
return __u_is_negative ? strong_ordering::greater : strong_ordering::less;
}
}
}
template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<0>)
noexcept(noexcept(strong_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
-> decltype( strong_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
{ return strong_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
template<class _Tp, class _Up>
_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>())))
-> decltype( __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>()))
{ return __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>()); }
};
} // namespace __strong_order
inline namespace __cpo {
inline constexpr auto strong_order = __strong_order::__fn{};
} // namespace __cpo
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS
#endif // _LIBCPP___COMPARE_STRONG_ORDER
diff --git a/contrib/llvm-project/libcxx/include/__compare/synth_three_way.h b/contrib/llvm-project/libcxx/include/__compare/synth_three_way.h
index 0f302c0fa11f..b93d4932c57f 100644
--- a/contrib/llvm-project/libcxx/include/__compare/synth_three_way.h
+++ b/contrib/llvm-project/libcxx/include/__compare/synth_three_way.h
@@ -1,51 +1,51 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___COMPARE_SYNTH_THREE_WAY_H
#define _LIBCPP___COMPARE_SYNTH_THREE_WAY_H
#include <__compare/ordering.h>
#include <__compare/three_way_comparable.h>
#include <__concepts/boolean_testable.h>
#include <__config>
#include <__utility/declval.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [expos.only.func]
_LIBCPP_HIDE_FROM_ABI inline constexpr auto __synth_three_way =
[]<class _Tp, class _Up>(const _Tp& __t, const _Up& __u)
requires requires {
{ __t < __u } -> __boolean_testable;
{ __u < __t } -> __boolean_testable;
}
{
if constexpr (three_way_comparable_with<_Tp, _Up>) {
return __t <=> __u;
} else {
if (__t < __u) return weak_ordering::less;
if (__u < __t) return weak_ordering::greater;
return weak_ordering::equivalent;
}
};
template <class _Tp, class _Up = _Tp>
using __synth_three_way_result = decltype(__synth_three_way(declval<_Tp&>(), declval<_Up&>()));
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_SYNTH_THREE_WAY_H
diff --git a/contrib/llvm-project/libcxx/include/__compare/three_way_comparable.h b/contrib/llvm-project/libcxx/include/__compare/three_way_comparable.h
index c4794949007b..548bf17f0feb 100644
--- a/contrib/llvm-project/libcxx/include/__compare/three_way_comparable.h
+++ b/contrib/llvm-project/libcxx/include/__compare/three_way_comparable.h
@@ -1,58 +1,58 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___COMPARE_THREE_WAY_COMPARABLE_H
#define _LIBCPP___COMPARE_THREE_WAY_COMPARABLE_H
#include <__compare/common_comparison_category.h>
#include <__compare/ordering.h>
#include <__concepts/common_reference_with.h>
#include <__concepts/equality_comparable.h>
#include <__concepts/same_as.h>
#include <__concepts/totally_ordered.h>
#include <__config>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template<class _Tp, class _Cat>
concept __compares_as =
same_as<common_comparison_category_t<_Tp, _Cat>, _Cat>;
template<class _Tp, class _Cat = partial_ordering>
concept three_way_comparable =
__weakly_equality_comparable_with<_Tp, _Tp> &&
__partially_ordered_with<_Tp, _Tp> &&
requires(__make_const_lvalue_ref<_Tp> __a, __make_const_lvalue_ref<_Tp> __b) {
{ __a <=> __b } -> __compares_as<_Cat>;
};
template<class _Tp, class _Up, class _Cat = partial_ordering>
concept three_way_comparable_with =
three_way_comparable<_Tp, _Cat> &&
three_way_comparable<_Up, _Cat> &&
common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>> &&
three_way_comparable<common_reference_t<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>>, _Cat> &&
__weakly_equality_comparable_with<_Tp, _Up> &&
__partially_ordered_with<_Tp, _Up> &&
requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
{ __t <=> __u } -> __compares_as<_Cat>;
{ __u <=> __t } -> __compares_as<_Cat>;
};
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_THREE_WAY_COMPARABLE_H
diff --git a/contrib/llvm-project/libcxx/include/__compare/weak_order.h b/contrib/llvm-project/libcxx/include/__compare/weak_order.h
index ce914b232108..1286f39b020c 100644
--- a/contrib/llvm-project/libcxx/include/__compare/weak_order.h
+++ b/contrib/llvm-project/libcxx/include/__compare/weak_order.h
@@ -1,100 +1,100 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___COMPARE_WEAK_ORDER
#define _LIBCPP___COMPARE_WEAK_ORDER
#include <__compare/compare_three_way.h>
#include <__compare/ordering.h>
#include <__compare/strong_order.h>
#include <__config>
#include <__utility/forward.h>
#include <__utility/priority_tag.h>
#include <cmath>
#include <type_traits>
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [cmp.alg]
namespace __weak_order {
struct __fn {
template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<3>)
noexcept(noexcept(weak_ordering(weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
-> decltype( weak_ordering(weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
{ return weak_ordering(weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
template<class _Tp, class _Up, class _Dp = decay_t<_Tp>>
requires is_same_v<_Dp, decay_t<_Up>> && is_floating_point_v<_Dp>
_LIBCPP_HIDE_FROM_ABI static constexpr weak_ordering
__go(_Tp&& __t, _Up&& __u, __priority_tag<2>) noexcept
{
partial_ordering __po = (__t <=> __u);
if (__po == partial_ordering::less) {
return weak_ordering::less;
} else if (__po == partial_ordering::equivalent) {
return weak_ordering::equivalent;
} else if (__po == partial_ordering::greater) {
return weak_ordering::greater;
} else {
// Otherwise, at least one of them is a NaN.
bool __t_is_nan = _VSTD::isnan(__t);
bool __u_is_nan = _VSTD::isnan(__u);
bool __t_is_negative = _VSTD::signbit(__t);
bool __u_is_negative = _VSTD::signbit(__u);
if (__t_is_nan && __u_is_nan) {
return (__u_is_negative <=> __t_is_negative);
} else if (__t_is_nan) {
return __t_is_negative ? weak_ordering::less : weak_ordering::greater;
} else {
return __u_is_negative ? weak_ordering::greater : weak_ordering::less;
}
}
}
template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<1>)
noexcept(noexcept(weak_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
-> decltype( weak_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
{ return weak_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<0>)
noexcept(noexcept(weak_ordering(_VSTD::strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
-> decltype( weak_ordering(_VSTD::strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
{ return weak_ordering(_VSTD::strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
template<class _Tp, class _Up>
_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<3>())))
-> decltype( __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<3>()))
{ return __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<3>()); }
};
} // namespace __weak_order
inline namespace __cpo {
inline constexpr auto weak_order = __weak_order::__fn{};
} // namespace __cpo
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_WEAK_ORDER
diff --git a/contrib/llvm-project/libcxx/include/__concepts/arithmetic.h b/contrib/llvm-project/libcxx/include/__concepts/arithmetic.h
index 9a1383904db6..c2f94239a6c3 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/arithmetic.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/arithmetic.h
@@ -1,48 +1,48 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_ARITHMETIC_H
#define _LIBCPP___CONCEPTS_ARITHMETIC_H
#include <__config>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concepts.arithmetic], arithmetic concepts
template<class _Tp>
concept integral = is_integral_v<_Tp>;
template<class _Tp>
concept signed_integral = integral<_Tp> && is_signed_v<_Tp>;
template<class _Tp>
concept unsigned_integral = integral<_Tp> && !signed_integral<_Tp>;
template<class _Tp>
concept floating_point = is_floating_point_v<_Tp>;
// Concept helpers for the internal type traits for the fundamental types.
template <class _Tp>
concept __libcpp_unsigned_integer = __libcpp_is_unsigned_integer<_Tp>::value;
template <class _Tp>
concept __libcpp_signed_integer = __libcpp_is_signed_integer<_Tp>::value;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_ARITHMETIC_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/assignable.h b/contrib/llvm-project/libcxx/include/__concepts/assignable.h
index 9cfc7c0e8318..62f39f1c8cdd 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/assignable.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/assignable.h
@@ -1,40 +1,40 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_ASSIGNABLE_H
#define _LIBCPP___CONCEPTS_ASSIGNABLE_H
#include <__concepts/common_reference_with.h>
#include <__concepts/same_as.h>
#include <__config>
#include <__utility/forward.h>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.assignable]
template<class _Lhs, class _Rhs>
concept assignable_from =
is_lvalue_reference_v<_Lhs> &&
common_reference_with<__make_const_lvalue_ref<_Lhs>, __make_const_lvalue_ref<_Rhs>> &&
requires (_Lhs __lhs, _Rhs&& __rhs) {
{ __lhs = _VSTD::forward<_Rhs>(__rhs) } -> same_as<_Lhs>;
};
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_ASSIGNABLE_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/boolean_testable.h b/contrib/llvm-project/libcxx/include/__concepts/boolean_testable.h
index 638fc3b20330..c04c30429166 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/boolean_testable.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/boolean_testable.h
@@ -1,38 +1,38 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_BOOLEAN_TESTABLE_H
#define _LIBCPP___CONCEPTS_BOOLEAN_TESTABLE_H
#include <__concepts/convertible_to.h>
#include <__config>
#include <__utility/forward.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concepts.booleantestable]
template<class _Tp>
concept __boolean_testable_impl = convertible_to<_Tp, bool>;
template<class _Tp>
concept __boolean_testable = __boolean_testable_impl<_Tp> && requires(_Tp&& __t) {
{ !_VSTD::forward<_Tp>(__t) } -> __boolean_testable_impl;
};
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_BOOLEAN_TESTABLE_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/class_or_enum.h b/contrib/llvm-project/libcxx/include/__concepts/class_or_enum.h
index aa8606a21929..3d28a8ad984d 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/class_or_enum.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/class_or_enum.h
@@ -1,36 +1,36 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_CLASS_OR_ENUM_H
#define _LIBCPP___CONCEPTS_CLASS_OR_ENUM_H
#include <__config>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// Whether a type is a class type or enumeration type according to the Core wording.
template<class _Tp>
concept __class_or_enum = is_class_v<_Tp> || is_union_v<_Tp> || is_enum_v<_Tp>;
// Work around Clang bug https://llvm.org/PR52970
template<class _Tp>
concept __workaround_52970 = is_class_v<__uncvref_t<_Tp>> || is_union_v<__uncvref_t<_Tp>>;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_CLASS_OR_ENUM_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/common_reference_with.h b/contrib/llvm-project/libcxx/include/__concepts/common_reference_with.h
index 3269e3ae89fe..119d8fd8deed 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/common_reference_with.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/common_reference_with.h
@@ -1,37 +1,37 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_COMMON_REFERENCE_WITH_H
#define _LIBCPP___CONCEPTS_COMMON_REFERENCE_WITH_H
#include <__concepts/convertible_to.h>
#include <__concepts/same_as.h>
#include <__config>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.commonref]
template<class _Tp, class _Up>
concept common_reference_with =
same_as<common_reference_t<_Tp, _Up>, common_reference_t<_Up, _Tp>> &&
convertible_to<_Tp, common_reference_t<_Tp, _Up>> &&
convertible_to<_Up, common_reference_t<_Tp, _Up>>;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_COMMON_REFERENCE_WITH_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/common_with.h b/contrib/llvm-project/libcxx/include/__concepts/common_with.h
index b575aea5f77f..ecaa23b63b22 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/common_with.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/common_with.h
@@ -1,47 +1,47 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_COMMON_WITH_H
#define _LIBCPP___CONCEPTS_COMMON_WITH_H
#include <__concepts/common_reference_with.h>
#include <__concepts/same_as.h>
#include <__config>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.common]
template<class _Tp, class _Up>
concept common_with =
same_as<common_type_t<_Tp, _Up>, common_type_t<_Up, _Tp>> &&
requires {
static_cast<common_type_t<_Tp, _Up>>(declval<_Tp>());
static_cast<common_type_t<_Tp, _Up>>(declval<_Up>());
} &&
common_reference_with<
add_lvalue_reference_t<const _Tp>,
add_lvalue_reference_t<const _Up>> &&
common_reference_with<
add_lvalue_reference_t<common_type_t<_Tp, _Up>>,
common_reference_t<
add_lvalue_reference_t<const _Tp>,
add_lvalue_reference_t<const _Up>>>;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_COMMON_WITH_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/constructible.h b/contrib/llvm-project/libcxx/include/__concepts/constructible.h
index 9bba8118b899..49986bb248d5 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/constructible.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/constructible.h
@@ -1,56 +1,56 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_CONSTRUCTIBLE_H
#define _LIBCPP___CONCEPTS_CONSTRUCTIBLE_H
#include <__concepts/convertible_to.h>
#include <__concepts/destructible.h>
#include <__config>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.constructible]
template<class _Tp, class... _Args>
concept constructible_from =
destructible<_Tp> && is_constructible_v<_Tp, _Args...>;
// [concept.default.init]
template<class _Tp>
concept __default_initializable = requires { ::new _Tp; };
template<class _Tp>
concept default_initializable = constructible_from<_Tp> &&
requires { _Tp{}; } && __default_initializable<_Tp>;
// [concept.moveconstructible]
template<class _Tp>
concept move_constructible =
constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>;
// [concept.copyconstructible]
template<class _Tp>
concept copy_constructible =
move_constructible<_Tp> &&
constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp> &&
constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp> &&
constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_CONSTRUCTIBLE_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/convertible_to.h b/contrib/llvm-project/libcxx/include/__concepts/convertible_to.h
index 795b0bd7494c..75f5da203c96 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/convertible_to.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/convertible_to.h
@@ -1,37 +1,37 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_CONVERTIBLE_TO_H
#define _LIBCPP___CONCEPTS_CONVERTIBLE_TO_H
#include <__config>
#include <__utility/declval.h>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.convertible]
template<class _From, class _To>
concept convertible_to =
is_convertible_v<_From, _To> &&
requires {
static_cast<_To>(declval<_From>());
};
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_CONVERTIBLE_TO_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/copyable.h b/contrib/llvm-project/libcxx/include/__concepts/copyable.h
index cfeeec86917e..c264b31a21ca 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/copyable.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/copyable.h
@@ -1,39 +1,39 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_COPYABLE_H
#define _LIBCPP___CONCEPTS_COPYABLE_H
#include <__concepts/assignable.h>
#include <__concepts/constructible.h>
#include <__concepts/movable.h>
#include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concepts.object]
template<class _Tp>
concept copyable =
copy_constructible<_Tp> &&
movable<_Tp> &&
assignable_from<_Tp&, _Tp&> &&
assignable_from<_Tp&, const _Tp&> &&
assignable_from<_Tp&, const _Tp>;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_COPYABLE_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/derived_from.h b/contrib/llvm-project/libcxx/include/__concepts/derived_from.h
index f7c83bf31fba..acd4ba473cdd 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/derived_from.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/derived_from.h
@@ -1,34 +1,34 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_DERIVED_FROM_H
#define _LIBCPP___CONCEPTS_DERIVED_FROM_H
#include <__config>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.derived]
template<class _Dp, class _Bp>
concept derived_from =
is_base_of_v<_Bp, _Dp> &&
is_convertible_v<const volatile _Dp*, const volatile _Bp*>;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_DERIVED_FROM_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/destructible.h b/contrib/llvm-project/libcxx/include/__concepts/destructible.h
index 800ee2d56f04..d57824be9e19 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/destructible.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/destructible.h
@@ -1,32 +1,32 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_DESTRUCTIBLE_H
#define _LIBCPP___CONCEPTS_DESTRUCTIBLE_H
#include <__config>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.destructible]
template<class _Tp>
concept destructible = is_nothrow_destructible_v<_Tp>;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_DESTRUCTIBLE_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/different_from.h b/contrib/llvm-project/libcxx/include/__concepts/different_from.h
index 5def31e652a5..c8560baf8af4 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/different_from.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/different_from.h
@@ -1,31 +1,31 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_DIFFERENT_FROM_H
#define _LIBCPP___CONCEPTS_DIFFERENT_FROM_H
#include <__concepts/same_as.h>
#include <__config>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template<class _Tp, class _Up>
concept __different_from = !same_as<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_DIFFERENT_FROM_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/equality_comparable.h b/contrib/llvm-project/libcxx/include/__concepts/equality_comparable.h
index 5df812c2600d..064143b89443 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/equality_comparable.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/equality_comparable.h
@@ -1,53 +1,53 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_EQUALITY_COMPARABLE_H
#define _LIBCPP___CONCEPTS_EQUALITY_COMPARABLE_H
#include <__concepts/boolean_testable.h>
#include <__concepts/common_reference_with.h>
#include <__config>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.equalitycomparable]
template<class _Tp, class _Up>
concept __weakly_equality_comparable_with =
requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
{ __t == __u } -> __boolean_testable;
{ __t != __u } -> __boolean_testable;
{ __u == __t } -> __boolean_testable;
{ __u != __t } -> __boolean_testable;
};
template<class _Tp>
concept equality_comparable = __weakly_equality_comparable_with<_Tp, _Tp>;
template<class _Tp, class _Up>
concept equality_comparable_with =
equality_comparable<_Tp> && equality_comparable<_Up> &&
common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>> &&
equality_comparable<
common_reference_t<
__make_const_lvalue_ref<_Tp>,
__make_const_lvalue_ref<_Up>>> &&
__weakly_equality_comparable_with<_Tp, _Up>;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_EQUALITY_COMPARABLE_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/invocable.h b/contrib/llvm-project/libcxx/include/__concepts/invocable.h
index 0a8d9b7255ab..e528258e3583 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/invocable.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/invocable.h
@@ -1,41 +1,41 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_INVOCABLE_H
#define _LIBCPP___CONCEPTS_INVOCABLE_H
#include <__config>
#include <__functional/invoke.h>
#include <__utility/forward.h>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.invocable]
template<class _Fn, class... _Args>
concept invocable = requires(_Fn&& __fn, _Args&&... __args) {
_VSTD::invoke(_VSTD::forward<_Fn>(__fn), _VSTD::forward<_Args>(__args)...); // not required to be equality preserving
};
// [concept.regular.invocable]
template<class _Fn, class... _Args>
concept regular_invocable = invocable<_Fn, _Args...>;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_INVOCABLE_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/movable.h b/contrib/llvm-project/libcxx/include/__concepts/movable.h
index dd0b8fb56d5b..fd8c2e7fa20e 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/movable.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/movable.h
@@ -1,39 +1,39 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_MOVABLE_H
#define _LIBCPP___CONCEPTS_MOVABLE_H
#include <__concepts/assignable.h>
#include <__concepts/constructible.h>
#include <__concepts/swappable.h>
#include <__config>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concepts.object]
template<class _Tp>
concept movable =
is_object_v<_Tp> &&
move_constructible<_Tp> &&
assignable_from<_Tp&, _Tp> &&
swappable<_Tp>;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_MOVABLE_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/predicate.h b/contrib/llvm-project/libcxx/include/__concepts/predicate.h
index 8e885406316d..491a7d6c73ea 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/predicate.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/predicate.h
@@ -1,35 +1,35 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_PREDICATE_H
#define _LIBCPP___CONCEPTS_PREDICATE_H
#include <__concepts/boolean_testable.h>
#include <__concepts/invocable.h>
#include <__config>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.predicate]
template<class _Fn, class... _Args>
concept predicate =
regular_invocable<_Fn, _Args...> && __boolean_testable<invoke_result_t<_Fn, _Args...>>;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_PREDICATE_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/regular.h b/contrib/llvm-project/libcxx/include/__concepts/regular.h
index d292e8d72dbe..e8a87c97febf 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/regular.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/regular.h
@@ -1,33 +1,33 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_REGULAR_H
#define _LIBCPP___CONCEPTS_REGULAR_H
#include <__concepts/equality_comparable.h>
#include <__concepts/semiregular.h>
#include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.object]
template<class _Tp>
concept regular = semiregular<_Tp> && equality_comparable<_Tp>;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_REGULAR_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/relation.h b/contrib/llvm-project/libcxx/include/__concepts/relation.h
index c6ff20d15195..fa7e5d17df88 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/relation.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/relation.h
@@ -1,44 +1,44 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_RELATION_H
#define _LIBCPP___CONCEPTS_RELATION_H
#include <__concepts/predicate.h>
#include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.relation]
template<class _Rp, class _Tp, class _Up>
concept relation =
predicate<_Rp, _Tp, _Tp> && predicate<_Rp, _Up, _Up> &&
predicate<_Rp, _Tp, _Up> && predicate<_Rp, _Up, _Tp>;
// [concept.equiv]
template<class _Rp, class _Tp, class _Up>
concept equivalence_relation = relation<_Rp, _Tp, _Up>;
// [concept.strictweakorder]
template<class _Rp, class _Tp, class _Up>
concept strict_weak_order = relation<_Rp, _Tp, _Up>;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_RELATION_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/same_as.h b/contrib/llvm-project/libcxx/include/__concepts/same_as.h
index 5a912b6f41c8..ee86c44ea35d 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/same_as.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/same_as.h
@@ -1,35 +1,35 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_SAME_AS_H
#define _LIBCPP___CONCEPTS_SAME_AS_H
#include <__config>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.same]
template<class _Tp, class _Up>
concept __same_as_impl = _IsSame<_Tp, _Up>::value;
template<class _Tp, class _Up>
concept same_as = __same_as_impl<_Tp, _Up> && __same_as_impl<_Up, _Tp>;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_SAME_AS_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/semiregular.h b/contrib/llvm-project/libcxx/include/__concepts/semiregular.h
index 4b96fe6dfba6..4797fc7eaa64 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/semiregular.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/semiregular.h
@@ -1,33 +1,33 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_SEMIREGULAR_H
#define _LIBCPP___CONCEPTS_SEMIREGULAR_H
#include <__concepts/constructible.h>
#include <__concepts/copyable.h>
#include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.object]
template<class _Tp>
concept semiregular = copyable<_Tp> && default_initializable<_Tp>;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_SEMIREGULAR_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/swappable.h b/contrib/llvm-project/libcxx/include/__concepts/swappable.h
index d45249738535..6b8cf82b70ef 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/swappable.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/swappable.h
@@ -1,116 +1,116 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_SWAPPABLE_H
#define _LIBCPP___CONCEPTS_SWAPPABLE_H
#include <__concepts/assignable.h>
#include <__concepts/class_or_enum.h>
#include <__concepts/common_reference_with.h>
#include <__concepts/constructible.h>
#include <__config>
#include <__utility/exchange.h>
#include <__utility/forward.h>
#include <__utility/move.h>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.swappable]
namespace ranges {
namespace __swap {
template<class _Tp>
void swap(_Tp&, _Tp&) = delete;
template<class _Tp, class _Up>
concept __unqualified_swappable_with =
(__class_or_enum<remove_cvref_t<_Tp>> || __class_or_enum<remove_cvref_t<_Up>>) &&
requires(_Tp&& __t, _Up&& __u) {
swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
};
struct __fn;
template<class _Tp, class _Up, size_t _Size>
concept __swappable_arrays =
!__unqualified_swappable_with<_Tp(&)[_Size], _Up(&)[_Size]> &&
extent_v<_Tp> == extent_v<_Up> &&
requires(_Tp(& __t)[_Size], _Up(& __u)[_Size], const __fn& __swap) {
__swap(__t[0], __u[0]);
};
template<class _Tp>
concept __exchangeable =
!__unqualified_swappable_with<_Tp&, _Tp&> &&
move_constructible<_Tp> &&
assignable_from<_Tp&, _Tp>;
struct __fn {
// 2.1 `S` is `(void)swap(E1, E2)`* if `E1` or `E2` has class or enumeration type and...
// *The name `swap` is used here unqualified.
template<class _Tp, class _Up>
requires __unqualified_swappable_with<_Tp, _Up>
constexpr void operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
{
swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
}
// 2.2 Otherwise, if `E1` and `E2` are lvalues of array types with equal extent and...
template<class _Tp, class _Up, size_t _Size>
requires __swappable_arrays<_Tp, _Up, _Size>
constexpr void operator()(_Tp(& __t)[_Size], _Up(& __u)[_Size]) const
noexcept(noexcept((*this)(*__t, *__u)))
{
// TODO(cjdb): replace with `ranges::swap_ranges`.
for (size_t __i = 0; __i < _Size; ++__i) {
(*this)(__t[__i], __u[__i]);
}
}
// 2.3 Otherwise, if `E1` and `E2` are lvalues of the same type `T` that models...
template<__exchangeable _Tp>
constexpr void operator()(_Tp& __x, _Tp& __y) const
noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_move_assignable_v<_Tp>)
{
__y = _VSTD::exchange(__x, _VSTD::move(__y));
}
};
} // namespace __swap
inline namespace __cpo {
inline constexpr auto swap = __swap::__fn{};
} // namespace __cpo
} // namespace ranges
template<class _Tp>
concept swappable = requires(_Tp& __a, _Tp& __b) { ranges::swap(__a, __b); };
template<class _Tp, class _Up>
concept swappable_with =
common_reference_with<_Tp, _Up> &&
requires(_Tp&& __t, _Up&& __u) {
ranges::swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Tp>(__t));
ranges::swap(_VSTD::forward<_Up>(__u), _VSTD::forward<_Up>(__u));
ranges::swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
ranges::swap(_VSTD::forward<_Up>(__u), _VSTD::forward<_Tp>(__t));
};
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_SWAPPABLE_H
diff --git a/contrib/llvm-project/libcxx/include/__concepts/totally_ordered.h b/contrib/llvm-project/libcxx/include/__concepts/totally_ordered.h
index d8dd4a4944d0..58dcb42be579 100644
--- a/contrib/llvm-project/libcxx/include/__concepts/totally_ordered.h
+++ b/contrib/llvm-project/libcxx/include/__concepts/totally_ordered.h
@@ -1,57 +1,57 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CONCEPTS_TOTALLY_ORDERED_H
#define _LIBCPP___CONCEPTS_TOTALLY_ORDERED_H
#include <__concepts/boolean_testable.h>
#include <__concepts/equality_comparable.h>
#include <__config>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.totallyordered]
template<class _Tp, class _Up>
concept __partially_ordered_with =
requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
{ __t < __u } -> __boolean_testable;
{ __t > __u } -> __boolean_testable;
{ __t <= __u } -> __boolean_testable;
{ __t >= __u } -> __boolean_testable;
{ __u < __t } -> __boolean_testable;
{ __u > __t } -> __boolean_testable;
{ __u <= __t } -> __boolean_testable;
{ __u >= __t } -> __boolean_testable;
};
template<class _Tp>
concept totally_ordered = equality_comparable<_Tp> && __partially_ordered_with<_Tp, _Tp>;
template<class _Tp, class _Up>
concept totally_ordered_with =
totally_ordered<_Tp> && totally_ordered<_Up> &&
equality_comparable_with<_Tp, _Up> &&
totally_ordered<
common_reference_t<
__make_const_lvalue_ref<_Tp>,
__make_const_lvalue_ref<_Up>>> &&
__partially_ordered_with<_Tp, _Up>;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_TOTALLY_ORDERED_H
diff --git a/contrib/llvm-project/libcxx/include/__config b/contrib/llvm-project/libcxx/include/__config
index 3c3d4b57c76e..d2d70c4ed769 100644
--- a/contrib/llvm-project/libcxx/include/__config
+++ b/contrib/llvm-project/libcxx/include/__config
@@ -1,1433 +1,1433 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_CONFIG
#define _LIBCPP_CONFIG
#include <__config_site>
#if defined(_MSC_VER) && !defined(__clang__)
# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# define _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
# endif
#endif
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
#pragma GCC system_header
#endif
#ifdef __cplusplus
#define _LIBCPP_VERSION 14000
#ifndef _LIBCPP_ABI_VERSION
# define _LIBCPP_ABI_VERSION 1
#endif
#if __STDC_HOSTED__ == 0
# define _LIBCPP_FREESTANDING
#endif
#ifndef _LIBCPP_STD_VER
# if __cplusplus <= 201103L
# define _LIBCPP_STD_VER 11
# elif __cplusplus <= 201402L
# define _LIBCPP_STD_VER 14
# elif __cplusplus <= 201703L
# define _LIBCPP_STD_VER 17
# elif __cplusplus <= 202002L
# define _LIBCPP_STD_VER 20
# else
# define _LIBCPP_STD_VER 21 // current year, or date of c++2b ratification
# endif
#endif // _LIBCPP_STD_VER
#if defined(__ELF__)
# define _LIBCPP_OBJECT_FORMAT_ELF 1
#elif defined(__MACH__)
# define _LIBCPP_OBJECT_FORMAT_MACHO 1
#elif defined(_WIN32)
# define _LIBCPP_OBJECT_FORMAT_COFF 1
#elif defined(__wasm__)
# define _LIBCPP_OBJECT_FORMAT_WASM 1
#else
// ... add new file formats here ...
#endif
#if defined(_LIBCPP_ABI_UNSTABLE) || _LIBCPP_ABI_VERSION >= 2
// Change short string representation so that string data starts at offset 0,
// improving its alignment in some cases.
# define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
// Fix deque iterator type in order to support incomplete types.
# define _LIBCPP_ABI_INCOMPLETE_TYPES_IN_DEQUE
// Fix undefined behavior in how std::list stores its linked nodes.
# define _LIBCPP_ABI_LIST_REMOVE_NODE_POINTER_UB
// Fix undefined behavior in how __tree stores its end and parent nodes.
# define _LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB
// Fix undefined behavior in how __hash_table stores its pointer types.
# define _LIBCPP_ABI_FIX_UNORDERED_NODE_POINTER_UB
# define _LIBCPP_ABI_FORWARD_LIST_REMOVE_NODE_POINTER_UB
# define _LIBCPP_ABI_FIX_UNORDERED_CONTAINER_SIZE_TYPE
// Define a key function for `bad_function_call` in the library, to centralize
// its vtable and typeinfo to libc++ rather than having all other libraries
// using that class define their own copies.
# define _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
// Override the default return value of exception::what() for
// bad_function_call::what() with a string that is specific to
// bad_function_call (see http://wg21.link/LWG2233). This is an ABI break
// because it changes the vtable layout of bad_function_call.
# define _LIBCPP_ABI_BAD_FUNCTION_CALL_GOOD_WHAT_MESSAGE
// Enable optimized version of __do_get_(un)signed which avoids redundant copies.
# define _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
// In C++20 and later, don't derive std::plus from std::binary_function,
// nor std::negate from std::unary_function.
# define _LIBCPP_ABI_NO_BINDER_BASES
// Give reverse_iterator<T> one data member of type T, not two.
// Also, in C++17 and later, don't derive iterator types from std::iterator.
# define _LIBCPP_ABI_NO_ITERATOR_BASES
// Use the smallest possible integer type to represent the index of the variant.
// Previously libc++ used "unsigned int" exclusively.
# define _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION
// Unstable attempt to provide a more optimized std::function
# define _LIBCPP_ABI_OPTIMIZED_FUNCTION
// All the regex constants must be distinct and nonzero.
# define _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO
// Use raw pointers, not wrapped ones, for std::span's iterator type.
# define _LIBCPP_ABI_SPAN_POINTER_ITERATORS
// Re-worked external template instantiations for std::string with a focus on
// performance and fast-path inlining.
# define _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
// Enable clang::trivial_abi on std::unique_ptr.
# define _LIBCPP_ABI_ENABLE_UNIQUE_PTR_TRIVIAL_ABI
// Enable clang::trivial_abi on std::shared_ptr and std::weak_ptr
# define _LIBCPP_ABI_ENABLE_SHARED_PTR_TRIVIAL_ABI
// std::random_device holds some state when it uses an implementation that gets
// entropy from a file (see _LIBCPP_USING_DEV_RANDOM). When switching from this
// implementation to another one on a platform that has already shipped
// std::random_device, one needs to retain the same object layout to remain ABI
// compatible. This switch removes these workarounds for platforms that don't care
// about ABI compatibility.
# define _LIBCPP_ABI_NO_RANDOM_DEVICE_COMPATIBILITY_LAYOUT
// Remove basic_string common base
-# define _LIBCPP_ABI_NO_BASIC_STRING_BASE_CLASS
+# define _LIBCPP_ABI_DO_NOT_EXPORT_BASIC_STRING_COMMON
#elif _LIBCPP_ABI_VERSION == 1
# if !defined(_LIBCPP_OBJECT_FORMAT_COFF)
// Enable compiling copies of now inline methods into the dylib to support
// applications compiled against older libraries. This is unnecessary with
// COFF dllexport semantics, since dllexport forces a non-inline definition
// of inline functions to be emitted anyway. Our own non-inline copy would
// conflict with the dllexport-emitted copy, so we disable it.
# define _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS
# endif
// Feature macros for disabling pre ABI v1 features. All of these options
// are deprecated.
# if defined(__FreeBSD__)
# define _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR
# endif
#endif
// By default, don't use a nullptr_t emulation type in C++03.
//
// This is technically an ABI break from previous releases, however it is
// very unlikely to impact anyone. If a user is impacted by this break,
// they can return to using the C++03 nullptr emulation by defining
// _LIBCPP_ABI_USE_CXX03_NULLPTR_EMULATION.
//
// This switch will be removed entirely in favour of never providing a
// C++03 emulation after one release.
//
// IMPORTANT: IF YOU ARE READING THIS AND YOU TURN THIS MACRO ON, PLEASE LEAVE
// A COMMENT ON https://reviews.llvm.org/D109459 OR YOU WILL BE BROKEN
// IN THE FUTURE WHEN WE REMOVE THE ABILITY TO USE THE C++03 EMULATION.
#ifndef _LIBCPP_ABI_USE_CXX03_NULLPTR_EMULATION
# define _LIBCPP_ABI_ALWAYS_USE_CXX11_NULLPTR
#endif
#if defined(_LIBCPP_BUILDING_LIBRARY) || defined(_LIBCPP_ABI_UNSTABLE) || _LIBCPP_ABI_VERSION >= 2
// Enable additional explicit instantiations of iostreams components. This
// reduces the number of weak definitions generated in programs that use
// iostreams by providing a single strong definition in the shared library.
# define _LIBCPP_ABI_ENABLE_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1
// Define a key function for `bad_function_call` in the library, to centralize
// its vtable and typeinfo to libc++ rather than having all other libraries
// using that class define their own copies.
# define _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
#endif
#define _LIBCPP_CONCAT1(_LIBCPP_X,_LIBCPP_Y) _LIBCPP_X##_LIBCPP_Y
#define _LIBCPP_CONCAT(_LIBCPP_X,_LIBCPP_Y) _LIBCPP_CONCAT1(_LIBCPP_X,_LIBCPP_Y)
#ifndef _LIBCPP_ABI_NAMESPACE
# define _LIBCPP_ABI_NAMESPACE _LIBCPP_CONCAT(__,_LIBCPP_ABI_VERSION)
#endif
#if __cplusplus < 201103L
#define _LIBCPP_CXX03_LANG
#endif
#ifndef __has_attribute
#define __has_attribute(__x) 0
#endif
#ifndef __has_builtin
#define __has_builtin(__x) 0
#endif
#ifndef __has_extension
#define __has_extension(__x) 0
#endif
#ifndef __has_feature
#define __has_feature(__x) 0
#endif
#ifndef __has_cpp_attribute
#define __has_cpp_attribute(__x) 0
#endif
// '__is_identifier' returns '0' if '__x' is a reserved identifier provided by
// the compiler and '1' otherwise.
#ifndef __is_identifier
#define __is_identifier(__x) 1
#endif
#ifndef __has_declspec_attribute
#define __has_declspec_attribute(__x) 0
#endif
#define __has_keyword(__x) !(__is_identifier(__x))
#ifndef __has_include
#define __has_include(...) 0
#endif
#if defined(__apple_build_version__)
# define _LIBCPP_COMPILER_CLANG_BASED
# define _LIBCPP_APPLE_CLANG_VER (__apple_build_version__ / 10000)
#elif defined(__clang__)
# define _LIBCPP_COMPILER_CLANG_BASED
# define _LIBCPP_CLANG_VER (__clang_major__ * 100 + __clang_minor__)
#elif defined(__GNUC__)
# define _LIBCPP_COMPILER_GCC
#elif defined(_MSC_VER)
# define _LIBCPP_COMPILER_MSVC
#elif defined(__IBMCPP__)
# define _LIBCPP_COMPILER_IBM
#endif
#if defined(_LIBCPP_COMPILER_GCC) && __cplusplus < 201103L
#error "libc++ does not support using GCC with C++03. Please enable C++11"
#endif
// FIXME: ABI detection should be done via compiler builtin macros. This
// is just a placeholder until Clang implements such macros. For now assume
// that Windows compilers pretending to be MSVC++ target the Microsoft ABI,
// and allow the user to explicitly specify the ABI to handle cases where this
// heuristic falls short.
#if defined(_LIBCPP_ABI_FORCE_ITANIUM) && defined(_LIBCPP_ABI_FORCE_MICROSOFT)
# error "Only one of _LIBCPP_ABI_FORCE_ITANIUM and _LIBCPP_ABI_FORCE_MICROSOFT can be defined"
#elif defined(_LIBCPP_ABI_FORCE_ITANIUM)
# define _LIBCPP_ABI_ITANIUM
#elif defined(_LIBCPP_ABI_FORCE_MICROSOFT)
# define _LIBCPP_ABI_MICROSOFT
#else
# if defined(_WIN32) && defined(_MSC_VER)
# define _LIBCPP_ABI_MICROSOFT
# else
# define _LIBCPP_ABI_ITANIUM
# endif
#endif
#if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_NO_VCRUNTIME)
# define _LIBCPP_ABI_VCRUNTIME
#endif
// Need to detect which libc we're using if we're on Linux.
#if defined(__linux__)
# include <features.h>
# if defined(__GLIBC_PREREQ)
# define _LIBCPP_GLIBC_PREREQ(a, b) __GLIBC_PREREQ(a, b)
# else
# define _LIBCPP_GLIBC_PREREQ(a, b) 0
# endif // defined(__GLIBC_PREREQ)
#endif // defined(__linux__)
#if defined(__MVS__)
# include <features.h> // for __NATIVE_ASCII_F
#endif
#ifdef __LITTLE_ENDIAN__
# if __LITTLE_ENDIAN__
# define _LIBCPP_LITTLE_ENDIAN
# endif // __LITTLE_ENDIAN__
#endif // __LITTLE_ENDIAN__
#ifdef __BIG_ENDIAN__
# if __BIG_ENDIAN__
# define _LIBCPP_BIG_ENDIAN
# endif // __BIG_ENDIAN__
#endif // __BIG_ENDIAN__
#ifdef __BYTE_ORDER__
# if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
# define _LIBCPP_LITTLE_ENDIAN
# elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
# define _LIBCPP_BIG_ENDIAN
# endif // __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
#endif // __BYTE_ORDER__
#ifdef __FreeBSD__
# include <sys/endian.h>
# include <osreldate.h>
# if _BYTE_ORDER == _LITTLE_ENDIAN
# define _LIBCPP_LITTLE_ENDIAN
# else // _BYTE_ORDER == _LITTLE_ENDIAN
# define _LIBCPP_BIG_ENDIAN
# endif // _BYTE_ORDER == _LITTLE_ENDIAN
#endif // __FreeBSD__
#if defined(__NetBSD__) || defined(__OpenBSD__)
# include <sys/endian.h>
# if _BYTE_ORDER == _LITTLE_ENDIAN
# define _LIBCPP_LITTLE_ENDIAN
# else // _BYTE_ORDER == _LITTLE_ENDIAN
# define _LIBCPP_BIG_ENDIAN
# endif // _BYTE_ORDER == _LITTLE_ENDIAN
#endif // defined(__NetBSD__) || defined(__OpenBSD__)
#if defined(_WIN32)
# define _LIBCPP_WIN32API
# define _LIBCPP_LITTLE_ENDIAN
# define _LIBCPP_SHORT_WCHAR 1
// Both MinGW and native MSVC provide a "MSVC"-like environment
# define _LIBCPP_MSVCRT_LIKE
// If mingw not explicitly detected, assume using MS C runtime only if
// a MS compatibility version is specified.
# if defined(_MSC_VER) && !defined(__MINGW32__)
# define _LIBCPP_MSVCRT // Using Microsoft's C Runtime library
# endif
# if (defined(_M_AMD64) || defined(__x86_64__)) || (defined(_M_ARM) || defined(__arm__))
# define _LIBCPP_HAS_BITSCAN64
# endif
# define _LIBCPP_HAS_OPEN_WITH_WCHAR
# if defined(_LIBCPP_MSVCRT)
# define _LIBCPP_HAS_QUICK_EXIT
# endif
// Some CRT APIs are unavailable to store apps
# if defined(WINAPI_FAMILY)
# include <winapifamily.h>
# if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && \
(!defined(WINAPI_PARTITION_SYSTEM) || \
!WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_SYSTEM))
# define _LIBCPP_WINDOWS_STORE_APP
# endif
# endif
#endif // defined(_WIN32)
#ifdef __sun__
# include <sys/isa_defs.h>
# ifdef _LITTLE_ENDIAN
# define _LIBCPP_LITTLE_ENDIAN
# else
# define _LIBCPP_BIG_ENDIAN
# endif
#endif // __sun__
#if defined(_AIX) && !defined(__64BIT__)
// The size of wchar is 2 byte on 32-bit mode on AIX.
# define _LIBCPP_SHORT_WCHAR 1
#endif
// Libc++ supports various implementations of std::random_device.
//
// _LIBCPP_USING_DEV_RANDOM
// Read entropy from the given file, by default `/dev/urandom`.
// If a token is provided, it is assumed to be the path to a file
// to read entropy from. This is the default behavior if nothing
// else is specified. This implementation requires storing state
// inside `std::random_device`.
//
// _LIBCPP_USING_ARC4_RANDOM
// Use arc4random(). This allows obtaining random data even when
// using sandboxing mechanisms. On some platforms like Apple, this
// is the recommended source of entropy for user-space programs.
// When this option is used, the token passed to `std::random_device`'s
// constructor *must* be "/dev/urandom" -- anything else is an error.
//
// _LIBCPP_USING_GETENTROPY
// Use getentropy().
// When this option is used, the token passed to `std::random_device`'s
// constructor *must* be "/dev/urandom" -- anything else is an error.
//
// _LIBCPP_USING_FUCHSIA_CPRNG
// Use Fuchsia's zx_cprng_draw() system call, which is specified to
// deliver high-quality entropy and cannot fail.
// When this option is used, the token passed to `std::random_device`'s
// constructor *must* be "/dev/urandom" -- anything else is an error.
//
// _LIBCPP_USING_NACL_RANDOM
// NaCl's sandbox (which PNaCl also runs in) doesn't allow filesystem access,
// including accesses to the special files under `/dev`. This implementation
// uses the NaCL syscall `nacl_secure_random_init()` to get entropy.
// When this option is used, the token passed to `std::random_device`'s
// constructor *must* be "/dev/urandom" -- anything else is an error.
//
// _LIBCPP_USING_WIN32_RANDOM
// Use rand_s(), for use on Windows.
// When this option is used, the token passed to `std::random_device`'s
// constructor *must* be "/dev/urandom" -- anything else is an error.
#if defined(__OpenBSD__) || defined(__APPLE__)
# define _LIBCPP_USING_ARC4_RANDOM
#elif defined(__wasi__)
# define _LIBCPP_USING_GETENTROPY
#elif defined(__Fuchsia__)
# define _LIBCPP_USING_FUCHSIA_CPRNG
#elif defined(__native_client__)
# define _LIBCPP_USING_NACL_RANDOM
#elif defined(_LIBCPP_WIN32API)
# define _LIBCPP_USING_WIN32_RANDOM
#else
# define _LIBCPP_USING_DEV_RANDOM
#endif
#if !defined(_LIBCPP_LITTLE_ENDIAN) && !defined(_LIBCPP_BIG_ENDIAN)
# include <endian.h>
# if __BYTE_ORDER == __LITTLE_ENDIAN
# define _LIBCPP_LITTLE_ENDIAN
# elif __BYTE_ORDER == __BIG_ENDIAN
# define _LIBCPP_BIG_ENDIAN
# else // __BYTE_ORDER == __BIG_ENDIAN
# error unable to determine endian
# endif
#endif // !defined(_LIBCPP_LITTLE_ENDIAN) && !defined(_LIBCPP_BIG_ENDIAN)
#if __has_attribute(__no_sanitize__) && !defined(_LIBCPP_COMPILER_GCC)
# define _LIBCPP_NO_CFI __attribute__((__no_sanitize__("cfi")))
#else
# define _LIBCPP_NO_CFI
#endif
// If the compiler supports using_if_exists, pretend we have those functions and they'll
// be picked up if the C library provides them.
//
// TODO: Once we drop support for Clang 12, we can assume the compiler supports using_if_exists
// for platforms that don't have a conforming C11 library, so we can drop this whole thing.
#if __has_attribute(using_if_exists)
# define _LIBCPP_HAS_TIMESPEC_GET
# define _LIBCPP_HAS_QUICK_EXIT
# define _LIBCPP_HAS_ALIGNED_ALLOC
#else
#if (defined(__ISO_C_VISIBLE) && (__ISO_C_VISIBLE >= 2011)) || __cplusplus >= 201103L
# if defined(__FreeBSD__)
# define _LIBCPP_HAS_ALIGNED_ALLOC
# define _LIBCPP_HAS_QUICK_EXIT
# if __FreeBSD_version >= 1300064 || \
(__FreeBSD_version >= 1201504 && __FreeBSD_version < 1300000)
# define _LIBCPP_HAS_TIMESPEC_GET
# endif
# elif defined(__BIONIC__)
# if __ANDROID_API__ >= 21
# define _LIBCPP_HAS_QUICK_EXIT
# endif
# if __ANDROID_API__ >= 28
# define _LIBCPP_HAS_ALIGNED_ALLOC
# endif
# if __ANDROID_API__ >= 29
# define _LIBCPP_HAS_TIMESPEC_GET
# endif
# elif defined(__Fuchsia__) || defined(__wasi__) || defined(__NetBSD__)
# define _LIBCPP_HAS_ALIGNED_ALLOC
# define _LIBCPP_HAS_QUICK_EXIT
# define _LIBCPP_HAS_TIMESPEC_GET
# elif defined(__OpenBSD__)
# define _LIBCPP_HAS_ALIGNED_ALLOC
# define _LIBCPP_HAS_TIMESPEC_GET
# elif defined(__linux__)
# if !defined(_LIBCPP_HAS_MUSL_LIBC)
# if _LIBCPP_GLIBC_PREREQ(2, 15) || defined(__BIONIC__)
# define _LIBCPP_HAS_QUICK_EXIT
# endif
# if _LIBCPP_GLIBC_PREREQ(2, 17)
# define _LIBCPP_HAS_ALIGNED_ALLOC
# define _LIBCPP_HAS_TIMESPEC_GET
# endif
# else // defined(_LIBCPP_HAS_MUSL_LIBC)
# define _LIBCPP_HAS_ALIGNED_ALLOC
# define _LIBCPP_HAS_QUICK_EXIT
# define _LIBCPP_HAS_TIMESPEC_GET
# endif
# elif defined(_LIBCPP_MSVCRT)
// Using Microsoft's C Runtime library, not MinGW
# define _LIBCPP_HAS_TIMESPEC_GET
# elif defined(__APPLE__)
// timespec_get and aligned_alloc were introduced in macOS 10.15 and
// aligned releases
# if ((defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101500) || \
(defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 130000) || \
(defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 130000) || \
(defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 60000))
# define _LIBCPP_HAS_ALIGNED_ALLOC
# define _LIBCPP_HAS_TIMESPEC_GET
# endif
# endif // __APPLE__
#endif
#endif // __has_attribute(using_if_exists)
#ifndef _LIBCPP_CXX03_LANG
# define _LIBCPP_ALIGNOF(_Tp) alignof(_Tp)
#elif defined(_LIBCPP_COMPILER_CLANG_BASED)
# define _LIBCPP_ALIGNOF(_Tp) _Alignof(_Tp)
#else
# error "We don't know a correct way to implement alignof(T) in C++03 outside of Clang"
#endif
#define _LIBCPP_PREFERRED_ALIGNOF(_Tp) __alignof(_Tp)
#if defined(_LIBCPP_COMPILER_CLANG_BASED)
#if defined(_LIBCPP_ALTERNATE_STRING_LAYOUT)
# error _LIBCPP_ALTERNATE_STRING_LAYOUT is deprecated, please use _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT instead
#endif
#if defined(__APPLE__) && !defined(__i386__) && !defined(__x86_64__) && \
(!defined(__arm__) || __ARM_ARCH_7K__ >= 2)
# define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
#endif
#if __has_feature(cxx_alignas)
# define _ALIGNAS_TYPE(x) alignas(x)
# define _ALIGNAS(x) alignas(x)
#else
# define _ALIGNAS_TYPE(x) __attribute__((__aligned__(_LIBCPP_ALIGNOF(x))))
# define _ALIGNAS(x) __attribute__((__aligned__(x)))
#endif
#if __cplusplus < 201103L
typedef __char16_t char16_t;
typedef __char32_t char32_t;
#endif
#if !__has_feature(cxx_exceptions)
# define _LIBCPP_NO_EXCEPTIONS
#endif
#if !(__has_feature(cxx_strong_enums))
#define _LIBCPP_HAS_NO_STRONG_ENUMS
#endif
#if __has_feature(cxx_attributes)
# define _LIBCPP_NORETURN [[noreturn]]
#else
# define _LIBCPP_NORETURN __attribute__ ((noreturn))
#endif
#if !(__has_feature(cxx_nullptr))
# if (__has_extension(cxx_nullptr) || __has_keyword(__nullptr)) && defined(_LIBCPP_ABI_ALWAYS_USE_CXX11_NULLPTR)
# define nullptr __nullptr
# else
# define _LIBCPP_HAS_NO_NULLPTR
# endif
#endif
// Objective-C++ features (opt-in)
#if __has_feature(objc_arc)
#define _LIBCPP_HAS_OBJC_ARC
#endif
#if __has_feature(objc_arc_weak)
#define _LIBCPP_HAS_OBJC_ARC_WEAK
#endif
#if __has_extension(blocks)
# define _LIBCPP_HAS_EXTENSION_BLOCKS
#endif
#if defined(_LIBCPP_HAS_EXTENSION_BLOCKS) && defined(__APPLE__)
# define _LIBCPP_HAS_BLOCKS_RUNTIME
#endif
#if !(__has_feature(cxx_noexcept))
#define _LIBCPP_HAS_NO_NOEXCEPT
#endif
#if !__has_feature(address_sanitizer)
#define _LIBCPP_HAS_NO_ASAN
#endif
// Allow for build-time disabling of unsigned integer sanitization
#if __has_attribute(no_sanitize)
#define _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK __attribute__((__no_sanitize__("unsigned-integer-overflow")))
#endif
#define _LIBCPP_ALWAYS_INLINE __attribute__ ((__always_inline__))
#define _LIBCPP_DISABLE_EXTENSION_WARNING __extension__
#elif defined(_LIBCPP_COMPILER_GCC)
#define _ALIGNAS(x) __attribute__((__aligned__(x)))
#define _ALIGNAS_TYPE(x) __attribute__((__aligned__(_LIBCPP_ALIGNOF(x))))
#define _LIBCPP_NORETURN __attribute__((noreturn))
#if !defined(__EXCEPTIONS)
# define _LIBCPP_NO_EXCEPTIONS
#endif
#if !defined(__SANITIZE_ADDRESS__)
#define _LIBCPP_HAS_NO_ASAN
#endif
#define _LIBCPP_ALWAYS_INLINE __attribute__ ((__always_inline__))
#define _LIBCPP_DISABLE_EXTENSION_WARNING __extension__
#elif defined(_LIBCPP_COMPILER_MSVC)
#define _LIBCPP_TOSTRING2(x) #x
#define _LIBCPP_TOSTRING(x) _LIBCPP_TOSTRING2(x)
#define _LIBCPP_WARNING(x) __pragma(message(__FILE__ "(" _LIBCPP_TOSTRING(__LINE__) ") : warning note: " x))
#if _MSC_VER < 1900
#error "MSVC versions prior to Visual Studio 2015 are not supported"
#endif
#define __alignof__ __alignof
#define _LIBCPP_NORETURN __declspec(noreturn)
#define _ALIGNAS(x) __declspec(align(x))
#define _ALIGNAS_TYPE(x) alignas(x)
#define _LIBCPP_WEAK
#define _LIBCPP_HAS_NO_ASAN
#define _LIBCPP_ALWAYS_INLINE __forceinline
#define _LIBCPP_HAS_NO_VECTOR_EXTENSION
#define _LIBCPP_DISABLE_EXTENSION_WARNING
#elif defined(_LIBCPP_COMPILER_IBM)
#define _ALIGNAS(x) __attribute__((__aligned__(x)))
#define _ALIGNAS_TYPE(x) __attribute__((__aligned__(_LIBCPP_ALIGNOF(x))))
#define _ATTRIBUTE(x) __attribute__((x))
#define _LIBCPP_NORETURN __attribute__((noreturn))
#define _LIBCPP_HAS_NO_UNICODE_CHARS
#if defined(_AIX)
#define __MULTILOCALE_API
#endif
#define _LIBCPP_HAS_NO_ASAN
#define _LIBCPP_ALWAYS_INLINE __attribute__ ((__always_inline__))
#define _LIBCPP_HAS_NO_VECTOR_EXTENSION
#define _LIBCPP_DISABLE_EXTENSION_WARNING
#endif // _LIBCPP_COMPILER_[CLANG|GCC|MSVC|IBM]
#if defined(_LIBCPP_OBJECT_FORMAT_COFF)
#ifdef _DLL
# define _LIBCPP_CRT_FUNC __declspec(dllimport)
#else
# define _LIBCPP_CRT_FUNC
#endif
#if defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
# define _LIBCPP_DLL_VIS
# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS
# define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
# define _LIBCPP_OVERRIDABLE_FUNC_VIS
# define _LIBCPP_EXPORTED_FROM_ABI
#elif defined(_LIBCPP_BUILDING_LIBRARY)
# define _LIBCPP_DLL_VIS __declspec(dllexport)
# if defined(__MINGW32__)
# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS _LIBCPP_DLL_VIS
# define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
# else
# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS
# define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS _LIBCPP_DLL_VIS
# endif
# define _LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_DLL_VIS
# define _LIBCPP_EXPORTED_FROM_ABI __declspec(dllexport)
#else
# define _LIBCPP_DLL_VIS __declspec(dllimport)
# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS _LIBCPP_DLL_VIS
# define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
# define _LIBCPP_OVERRIDABLE_FUNC_VIS
# define _LIBCPP_EXPORTED_FROM_ABI __declspec(dllimport)
#endif
#define _LIBCPP_TYPE_VIS _LIBCPP_DLL_VIS
#define _LIBCPP_FUNC_VIS _LIBCPP_DLL_VIS
#define _LIBCPP_EXCEPTION_ABI _LIBCPP_DLL_VIS
#define _LIBCPP_HIDDEN
#define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
#define _LIBCPP_TEMPLATE_VIS
#define _LIBCPP_TEMPLATE_DATA_VIS
#define _LIBCPP_ENUM_VIS
#endif // defined(_LIBCPP_OBJECT_FORMAT_COFF)
#ifndef _LIBCPP_HIDDEN
# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
# define _LIBCPP_HIDDEN __attribute__ ((__visibility__("hidden")))
# else
# define _LIBCPP_HIDDEN
# endif
#endif
#ifndef _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
// The inline should be removed once PR32114 is resolved
# define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS inline _LIBCPP_HIDDEN
# else
# define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
# endif
#endif
#ifndef _LIBCPP_FUNC_VIS
# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
# define _LIBCPP_FUNC_VIS __attribute__ ((__visibility__("default")))
# else
# define _LIBCPP_FUNC_VIS
# endif
#endif
#ifndef _LIBCPP_TYPE_VIS
# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
# define _LIBCPP_TYPE_VIS __attribute__ ((__visibility__("default")))
# else
# define _LIBCPP_TYPE_VIS
# endif
#endif
#ifndef _LIBCPP_TEMPLATE_VIS
# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
# if __has_attribute(__type_visibility__)
# define _LIBCPP_TEMPLATE_VIS __attribute__ ((__type_visibility__("default")))
# else
# define _LIBCPP_TEMPLATE_VIS __attribute__ ((__visibility__("default")))
# endif
# else
# define _LIBCPP_TEMPLATE_VIS
# endif
#endif
#ifndef _LIBCPP_TEMPLATE_DATA_VIS
# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
# define _LIBCPP_TEMPLATE_DATA_VIS __attribute__ ((__visibility__("default")))
# else
# define _LIBCPP_TEMPLATE_DATA_VIS
# endif
#endif
#ifndef _LIBCPP_EXPORTED_FROM_ABI
# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
# define _LIBCPP_EXPORTED_FROM_ABI __attribute__((__visibility__("default")))
# else
# define _LIBCPP_EXPORTED_FROM_ABI
# endif
#endif
#ifndef _LIBCPP_OVERRIDABLE_FUNC_VIS
#define _LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_FUNC_VIS
#endif
#ifndef _LIBCPP_EXCEPTION_ABI
# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
# define _LIBCPP_EXCEPTION_ABI __attribute__ ((__visibility__("default")))
# else
# define _LIBCPP_EXCEPTION_ABI
# endif
#endif
#ifndef _LIBCPP_ENUM_VIS
# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS) && __has_attribute(__type_visibility__)
# define _LIBCPP_ENUM_VIS __attribute__ ((__type_visibility__("default")))
# else
# define _LIBCPP_ENUM_VIS
# endif
#endif
#ifndef _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS
# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __attribute__ ((__visibility__("default")))
# else
# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS
# endif
#endif
#ifndef _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
#define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
#endif
#if __has_attribute(internal_linkage)
# define _LIBCPP_INTERNAL_LINKAGE __attribute__ ((internal_linkage))
#else
# define _LIBCPP_INTERNAL_LINKAGE _LIBCPP_ALWAYS_INLINE
#endif
#if __has_attribute(exclude_from_explicit_instantiation)
# define _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION __attribute__ ((__exclude_from_explicit_instantiation__))
#else
// Try to approximate the effect of exclude_from_explicit_instantiation
// (which is that entities are not assumed to be provided by explicit
// template instantiations in the dylib) by always inlining those entities.
# define _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION _LIBCPP_ALWAYS_INLINE
#endif
#ifndef _LIBCPP_HIDE_FROM_ABI_PER_TU
# ifndef _LIBCPP_HIDE_FROM_ABI_PER_TU_BY_DEFAULT
# define _LIBCPP_HIDE_FROM_ABI_PER_TU 0
# else
# define _LIBCPP_HIDE_FROM_ABI_PER_TU 1
# endif
#endif
#ifndef _LIBCPP_HIDE_FROM_ABI
# if _LIBCPP_HIDE_FROM_ABI_PER_TU
# define _LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDDEN _LIBCPP_INTERNAL_LINKAGE
# else
# define _LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDDEN _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION
# endif
#endif
#ifdef _LIBCPP_BUILDING_LIBRARY
# if _LIBCPP_ABI_VERSION > 1
# define _LIBCPP_HIDE_FROM_ABI_AFTER_V1 _LIBCPP_HIDE_FROM_ABI
# else
# define _LIBCPP_HIDE_FROM_ABI_AFTER_V1
# endif
#else
# define _LIBCPP_HIDE_FROM_ABI_AFTER_V1 _LIBCPP_HIDE_FROM_ABI
#endif
// Just so we can migrate to the new macros gradually.
#define _LIBCPP_INLINE_VISIBILITY _LIBCPP_HIDE_FROM_ABI
// Inline namespaces are available in Clang/GCC/MSVC regardless of C++ dialect.
#define _LIBCPP_BEGIN_NAMESPACE_STD namespace std { inline namespace _LIBCPP_ABI_NAMESPACE {
#define _LIBCPP_END_NAMESPACE_STD } }
#define _VSTD std
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14
#define _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM \
_LIBCPP_BEGIN_NAMESPACE_STD inline namespace __fs { namespace filesystem {
#else
#define _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM \
_LIBCPP_BEGIN_NAMESPACE_STD namespace __fs { namespace filesystem {
#endif
#define _LIBCPP_END_NAMESPACE_FILESYSTEM \
_LIBCPP_END_NAMESPACE_STD } }
#define _VSTD_FS _VSTD::__fs::filesystem
#if __has_attribute(__enable_if__)
# define _LIBCPP_PREFERRED_OVERLOAD __attribute__ ((__enable_if__(true, "")))
#endif
#ifndef _LIBCPP_HAS_NO_NOEXCEPT
# define _NOEXCEPT noexcept
# define _NOEXCEPT_(x) noexcept(x)
#else
# define _NOEXCEPT throw()
# define _NOEXCEPT_(x)
#endif
#ifdef _LIBCPP_HAS_NO_UNICODE_CHARS
typedef unsigned short char16_t;
typedef unsigned int char32_t;
#endif
#ifndef __SIZEOF_INT128__
#define _LIBCPP_HAS_NO_INT128
#endif
#ifdef _LIBCPP_CXX03_LANG
# define static_assert(...) _Static_assert(__VA_ARGS__)
# define decltype(...) __decltype(__VA_ARGS__)
#endif // _LIBCPP_CXX03_LANG
#ifdef _LIBCPP_CXX03_LANG
# define _LIBCPP_CONSTEXPR
#else
# define _LIBCPP_CONSTEXPR constexpr
#endif
#ifndef __cpp_consteval
# define _LIBCPP_CONSTEVAL _LIBCPP_CONSTEXPR
#else
# define _LIBCPP_CONSTEVAL consteval
#endif
#if _LIBCPP_STD_VER <= 17 || !defined(__cpp_concepts) || __cpp_concepts < 201907L
#define _LIBCPP_HAS_NO_CONCEPTS
#endif
#ifdef __GNUC__
# define _LIBCPP_NOALIAS __attribute__((__malloc__))
#else
# define _LIBCPP_NOALIAS
#endif
#if __has_attribute(using_if_exists)
# define _LIBCPP_USING_IF_EXISTS __attribute__((using_if_exists))
#else
# define _LIBCPP_USING_IF_EXISTS
#endif
#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
# define _LIBCPP_DECLARE_STRONG_ENUM(x) struct _LIBCPP_TYPE_VIS x { enum __lx
# define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x) \
__lx __v_; \
_LIBCPP_INLINE_VISIBILITY x(__lx __v) : __v_(__v) {} \
_LIBCPP_INLINE_VISIBILITY explicit x(int __v) : __v_(static_cast<__lx>(__v)) {} \
_LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;} \
};
#else // _LIBCPP_HAS_NO_STRONG_ENUMS
# define _LIBCPP_DECLARE_STRONG_ENUM(x) enum class _LIBCPP_ENUM_VIS x
# define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x)
#endif // _LIBCPP_HAS_NO_STRONG_ENUMS
// _LIBCPP_DEBUG potential values:
// - undefined: No assertions. This is the default.
// - 0: Basic assertions
// - 1: Basic assertions + iterator validity checks + unspecified behavior randomization.
# if !defined(_LIBCPP_DEBUG)
# define _LIBCPP_DEBUG_LEVEL 0
# elif _LIBCPP_DEBUG == 0
# define _LIBCPP_DEBUG_LEVEL 1
# elif _LIBCPP_DEBUG == 1
# define _LIBCPP_DEBUG_LEVEL 2
# else
# error Supported values for _LIBCPP_DEBUG are 0 and 1
# endif
# if _LIBCPP_DEBUG_LEVEL >= 2 && !defined(_LIBCPP_CXX03_LANG)
# define _LIBCPP_DEBUG_RANDOMIZE_UNSPECIFIED_STABILITY
# endif
# if defined(_LIBCPP_DEBUG_RANDOMIZE_UNSPECIFIED_STABILITY)
# if defined(_LIBCPP_CXX03_LANG)
# error Support for unspecified stability is only for C++11 and higher
# endif
# define _LIBCPP_DEBUG_RANDOMIZE_RANGE(__first, __last) \
do { \
if (!__builtin_is_constant_evaluated()) \
_VSTD::shuffle(__first, __last, __libcpp_debug_randomizer()); \
} while (false)
# else
# define _LIBCPP_DEBUG_RANDOMIZE_RANGE(__first, __last) \
do { \
} while (false)
# endif
// Libc++ allows disabling extern template instantiation declarations by
// means of users defining _LIBCPP_DISABLE_EXTERN_TEMPLATE.
//
// Furthermore, when the Debug mode is enabled, we disable extern declarations
// when building user code because we don't want to use the functions compiled
// in the library, which might not have had the debug mode enabled when built.
// However, some extern declarations need to be used, because code correctness
// depends on it (several instances in <locale>). Those special declarations
// are declared with _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE, which is enabled
// even when the debug mode is enabled.
#if defined(_LIBCPP_DISABLE_EXTERN_TEMPLATE)
# define _LIBCPP_EXTERN_TEMPLATE(...) /* nothing */
# define _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(...) /* nothing */
#elif _LIBCPP_DEBUG_LEVEL >= 1 && !defined(_LIBCPP_BUILDING_LIBRARY)
# define _LIBCPP_EXTERN_TEMPLATE(...) /* nothing */
# define _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(...) extern template __VA_ARGS__;
#else
# define _LIBCPP_EXTERN_TEMPLATE(...) extern template __VA_ARGS__;
# define _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(...) extern template __VA_ARGS__;
#endif
#if defined(__APPLE__) || defined(__FreeBSD__) || defined(_LIBCPP_MSVCRT_LIKE) || \
defined(__sun__) || defined(__NetBSD__)
#define _LIBCPP_LOCALE__L_EXTENSIONS 1
#endif
#ifdef __FreeBSD__
#define _DECLARE_C99_LDBL_MATH 1
#endif
// If we are getting operator new from the MSVC CRT, then allocation overloads
// for align_val_t were added in 19.12, aka VS 2017 version 15.3.
#if defined(_LIBCPP_MSVCRT) && defined(_MSC_VER) && _MSC_VER < 1912
# define _LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
#elif defined(_LIBCPP_ABI_VCRUNTIME) && !defined(__cpp_aligned_new)
// We're deferring to Microsoft's STL to provide aligned new et al. We don't
// have it unless the language feature test macro is defined.
# define _LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
#elif defined(__MVS__)
# define _LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
#endif
#if defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION) || \
(!defined(__cpp_aligned_new) || __cpp_aligned_new < 201606)
# define _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
#endif
#if defined(__APPLE__) || defined(__FreeBSD__)
#define _LIBCPP_HAS_DEFAULTRUNELOCALE
#endif
#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__sun__)
#define _LIBCPP_WCTYPE_IS_MASK
#endif
#if _LIBCPP_STD_VER <= 17 || !defined(__cpp_char8_t)
#define _LIBCPP_HAS_NO_CHAR8_T
#endif
// Deprecation macros.
//
// Deprecations warnings are always enabled, except when users explicitly opt-out
// by defining _LIBCPP_DISABLE_DEPRECATION_WARNINGS.
#if !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS)
# if __has_attribute(deprecated)
# define _LIBCPP_DEPRECATED __attribute__ ((deprecated))
# elif _LIBCPP_STD_VER > 11
# define _LIBCPP_DEPRECATED [[deprecated]]
# else
# define _LIBCPP_DEPRECATED
# endif
#else
# define _LIBCPP_DEPRECATED
#endif
#if !defined(_LIBCPP_CXX03_LANG)
# define _LIBCPP_DEPRECATED_IN_CXX11 _LIBCPP_DEPRECATED
#else
# define _LIBCPP_DEPRECATED_IN_CXX11
#endif
#if _LIBCPP_STD_VER >= 14
# define _LIBCPP_DEPRECATED_IN_CXX14 _LIBCPP_DEPRECATED
#else
# define _LIBCPP_DEPRECATED_IN_CXX14
#endif
#if _LIBCPP_STD_VER >= 17
# define _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_DEPRECATED
#else
# define _LIBCPP_DEPRECATED_IN_CXX17
#endif
#if _LIBCPP_STD_VER > 17
# define _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_DEPRECATED
#else
# define _LIBCPP_DEPRECATED_IN_CXX20
#endif
#if !defined(_LIBCPP_HAS_NO_CHAR8_T)
# define _LIBCPP_DEPRECATED_WITH_CHAR8_T _LIBCPP_DEPRECATED
#else
# define _LIBCPP_DEPRECATED_WITH_CHAR8_T
#endif
// Macros to enter and leave a state where deprecation warnings are suppressed.
#if defined(_LIBCPP_COMPILER_CLANG_BASED) || defined(_LIBCPP_COMPILER_GCC)
# define _LIBCPP_SUPPRESS_DEPRECATED_PUSH \
_Pragma("GCC diagnostic push") \
_Pragma("GCC diagnostic ignored \"-Wdeprecated\"") \
_Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
# define _LIBCPP_SUPPRESS_DEPRECATED_POP \
_Pragma("GCC diagnostic pop")
#else
# define _LIBCPP_SUPPRESS_DEPRECATED_PUSH
# define _LIBCPP_SUPPRESS_DEPRECATED_POP
#endif
#if _LIBCPP_STD_VER <= 11
# define _LIBCPP_EXPLICIT_AFTER_CXX11
#else
# define _LIBCPP_EXPLICIT_AFTER_CXX11 explicit
#endif
#if _LIBCPP_STD_VER > 11
# define _LIBCPP_CONSTEXPR_AFTER_CXX11 constexpr
#else
# define _LIBCPP_CONSTEXPR_AFTER_CXX11
#endif
#if _LIBCPP_STD_VER > 14
# define _LIBCPP_CONSTEXPR_AFTER_CXX14 constexpr
#else
# define _LIBCPP_CONSTEXPR_AFTER_CXX14
#endif
#if _LIBCPP_STD_VER > 17
# define _LIBCPP_CONSTEXPR_AFTER_CXX17 constexpr
#else
# define _LIBCPP_CONSTEXPR_AFTER_CXX17
#endif
#if __has_cpp_attribute(nodiscard) || defined(_LIBCPP_COMPILER_MSVC)
# define _LIBCPP_NODISCARD [[nodiscard]]
#elif defined(_LIBCPP_COMPILER_CLANG_BASED) && !defined(_LIBCPP_CXX03_LANG)
# define _LIBCPP_NODISCARD [[clang::warn_unused_result]]
#else
// We can't use GCC's [[gnu::warn_unused_result]] and
// __attribute__((warn_unused_result)), because GCC does not silence them via
// (void) cast.
# define _LIBCPP_NODISCARD
#endif
// _LIBCPP_NODISCARD_EXT may be used to apply [[nodiscard]] to entities not
// specified as such as an extension.
#if defined(_LIBCPP_ENABLE_NODISCARD) && !defined(_LIBCPP_DISABLE_NODISCARD_EXT)
# define _LIBCPP_NODISCARD_EXT _LIBCPP_NODISCARD
#else
# define _LIBCPP_NODISCARD_EXT
#endif
#if !defined(_LIBCPP_DISABLE_NODISCARD_AFTER_CXX17) && \
(_LIBCPP_STD_VER > 17 || defined(_LIBCPP_ENABLE_NODISCARD))
# define _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_NODISCARD
#else
# define _LIBCPP_NODISCARD_AFTER_CXX17
#endif
#if __has_attribute(no_destroy)
# define _LIBCPP_NO_DESTROY __attribute__((__no_destroy__))
#else
# define _LIBCPP_NO_DESTROY
#endif
#ifndef _LIBCPP_HAS_NO_ASAN
extern "C" _LIBCPP_FUNC_VIS void __sanitizer_annotate_contiguous_container(
const void *, const void *, const void *, const void *);
#endif
// Try to find out if RTTI is disabled.
#if defined(_LIBCPP_COMPILER_CLANG_BASED) && !__has_feature(cxx_rtti)
# define _LIBCPP_NO_RTTI
#elif defined(__GNUC__) && !defined(__GXX_RTTI)
# define _LIBCPP_NO_RTTI
#elif defined(_LIBCPP_COMPILER_MSVC) && !defined(_CPPRTTI)
# define _LIBCPP_NO_RTTI
#endif
#ifndef _LIBCPP_WEAK
#define _LIBCPP_WEAK __attribute__((__weak__))
#endif
// Thread API
#if !defined(_LIBCPP_HAS_NO_THREADS) && \
!defined(_LIBCPP_HAS_THREAD_API_PTHREAD) && \
!defined(_LIBCPP_HAS_THREAD_API_WIN32) && \
!defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
# if defined(__FreeBSD__) || \
defined(__wasi__) || \
defined(__NetBSD__) || \
defined(__OpenBSD__) || \
defined(__NuttX__) || \
defined(__linux__) || \
defined(__GNU__) || \
defined(__APPLE__) || \
defined(__sun__) || \
defined(__MVS__) || \
defined(_AIX)
# define _LIBCPP_HAS_THREAD_API_PTHREAD
# elif defined(__Fuchsia__)
// TODO(44575): Switch to C11 thread API when possible.
# define _LIBCPP_HAS_THREAD_API_PTHREAD
# elif defined(_LIBCPP_WIN32API)
# define _LIBCPP_HAS_THREAD_API_WIN32
# else
# error "No thread API"
# endif // _LIBCPP_HAS_THREAD_API
#endif // _LIBCPP_HAS_NO_THREADS
#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
#if defined(__ANDROID__) && __ANDROID_API__ >= 30
#define _LIBCPP_HAS_COND_CLOCKWAIT
#elif defined(_LIBCPP_GLIBC_PREREQ)
#if _LIBCPP_GLIBC_PREREQ(2, 30)
#define _LIBCPP_HAS_COND_CLOCKWAIT
#endif
#endif
#endif
#if defined(_LIBCPP_HAS_NO_THREADS) && defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
#error _LIBCPP_HAS_THREAD_API_PTHREAD may only be defined when \
_LIBCPP_HAS_NO_THREADS is not defined.
#endif
#if defined(_LIBCPP_HAS_NO_THREADS) && defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
#error _LIBCPP_HAS_THREAD_API_EXTERNAL may not be defined when \
_LIBCPP_HAS_NO_THREADS is defined.
#endif
#if defined(_LIBCPP_HAS_NO_MONOTONIC_CLOCK) && !defined(_LIBCPP_HAS_NO_THREADS)
#error _LIBCPP_HAS_NO_MONOTONIC_CLOCK may only be defined when \
_LIBCPP_HAS_NO_THREADS is defined.
#endif
#if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(__STDCPP_THREADS__)
#define __STDCPP_THREADS__ 1
#endif
// The glibc and Bionic implementation of pthreads implements
// pthread_mutex_destroy as nop for regular mutexes. Additionally, Win32
// mutexes have no destroy mechanism.
//
// This optimization can't be performed on Apple platforms, where
// pthread_mutex_destroy can allow the kernel to release resources.
// See https://llvm.org/D64298 for details.
//
// TODO(EricWF): Enable this optimization on Bionic after speaking to their
// respective stakeholders.
#if (defined(_LIBCPP_HAS_THREAD_API_PTHREAD) && defined(__GLIBC__)) \
|| (defined(_LIBCPP_HAS_THREAD_API_C11) && defined(__Fuchsia__)) \
|| defined(_LIBCPP_HAS_THREAD_API_WIN32)
# define _LIBCPP_HAS_TRIVIAL_MUTEX_DESTRUCTION
#endif
// Destroying a condvar is a nop on Windows.
//
// This optimization can't be performed on Apple platforms, where
// pthread_cond_destroy can allow the kernel to release resources.
// See https://llvm.org/D64298 for details.
//
// TODO(EricWF): This is potentially true for some pthread implementations
// as well.
#if (defined(_LIBCPP_HAS_THREAD_API_C11) && defined(__Fuchsia__)) || \
defined(_LIBCPP_HAS_THREAD_API_WIN32)
# define _LIBCPP_HAS_TRIVIAL_CONDVAR_DESTRUCTION
#endif
// Some systems do not provide gets() in their C library, for security reasons.
#if defined(_LIBCPP_MSVCRT) || \
(defined(__FreeBSD_version) && __FreeBSD_version >= 1300043) || \
defined(__OpenBSD__)
# define _LIBCPP_C_HAS_NO_GETS
#endif
#if defined(__BIONIC__) || defined(__NuttX__) || \
defined(__Fuchsia__) || defined(__wasi__) || \
defined(_LIBCPP_HAS_MUSL_LIBC) || defined(__OpenBSD__)
#define _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE
#endif
#if __has_feature(cxx_atomic) || __has_extension(c_atomic) || __has_keyword(_Atomic)
# define _LIBCPP_HAS_C_ATOMIC_IMP
#elif defined(_LIBCPP_COMPILER_GCC)
# define _LIBCPP_HAS_GCC_ATOMIC_IMP
#endif
#if !defined(_LIBCPP_HAS_C_ATOMIC_IMP) && \
!defined(_LIBCPP_HAS_GCC_ATOMIC_IMP) && \
!defined(_LIBCPP_HAS_EXTERNAL_ATOMIC_IMP)
# define _LIBCPP_HAS_NO_ATOMIC_HEADER
#else
# ifndef _LIBCPP_ATOMIC_FLAG_TYPE
# define _LIBCPP_ATOMIC_FLAG_TYPE bool
# endif
# ifdef _LIBCPP_FREESTANDING
# define _LIBCPP_ATOMIC_ONLY_USE_BUILTINS
# endif
#endif
#ifndef _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
#define _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
#endif
#if defined(_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS)
# if defined(__clang__) && __has_attribute(acquire_capability)
// Work around the attribute handling in clang. When both __declspec and
// __attribute__ are present, the processing goes awry preventing the definition
// of the types. In MinGW mode, __declspec evaluates to __attribute__, and thus
// combining the two does work.
# if !defined(_MSC_VER)
# define _LIBCPP_HAS_THREAD_SAFETY_ANNOTATIONS
# endif
# endif
#endif
#ifdef _LIBCPP_HAS_THREAD_SAFETY_ANNOTATIONS
# define _LIBCPP_THREAD_SAFETY_ANNOTATION(x) __attribute__((x))
#else
# define _LIBCPP_THREAD_SAFETY_ANNOTATION(x)
#endif
#if __has_attribute(require_constant_initialization)
# define _LIBCPP_SAFE_STATIC __attribute__((__require_constant_initialization__))
#else
# define _LIBCPP_SAFE_STATIC
#endif
#if __has_attribute(diagnose_if) && !defined(_LIBCPP_DISABLE_ADDITIONAL_DIAGNOSTICS)
# define _LIBCPP_DIAGNOSE_WARNING(...) \
__attribute__((diagnose_if(__VA_ARGS__, "warning")))
# define _LIBCPP_DIAGNOSE_ERROR(...) \
__attribute__((diagnose_if(__VA_ARGS__, "error")))
#else
# define _LIBCPP_DIAGNOSE_WARNING(...)
# define _LIBCPP_DIAGNOSE_ERROR(...)
#endif
// Use a function like macro to imply that it must be followed by a semicolon
#if __cplusplus > 201402L && __has_cpp_attribute(fallthrough)
# define _LIBCPP_FALLTHROUGH() [[fallthrough]]
#elif __has_cpp_attribute(clang::fallthrough)
# define _LIBCPP_FALLTHROUGH() [[clang::fallthrough]]
#elif __has_attribute(__fallthrough__)
# define _LIBCPP_FALLTHROUGH() __attribute__((__fallthrough__))
#else
# define _LIBCPP_FALLTHROUGH() ((void)0)
#endif
#if __has_attribute(__nodebug__)
#define _LIBCPP_NODEBUG __attribute__((__nodebug__))
#else
#define _LIBCPP_NODEBUG
#endif
#if __has_attribute(__standalone_debug__)
#define _LIBCPP_STANDALONE_DEBUG __attribute__((__standalone_debug__))
#else
#define _LIBCPP_STANDALONE_DEBUG
#endif
#if __has_attribute(__preferred_name__)
#define _LIBCPP_PREFERRED_NAME(x) __attribute__((__preferred_name__(x)))
#else
#define _LIBCPP_PREFERRED_NAME(x)
#endif
// We often repeat things just for handling wide characters in the library.
// When wide characters are disabled, it can be useful to have a quick way of
// disabling it without having to resort to #if-#endif, which has a larger
// impact on readability.
#if defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
# define _LIBCPP_IF_WIDE_CHARACTERS(...)
#else
# define _LIBCPP_IF_WIDE_CHARACTERS(...) __VA_ARGS__
#endif
#if defined(_LIBCPP_ABI_MICROSOFT) && \
(defined(_LIBCPP_COMPILER_MSVC) || __has_declspec_attribute(empty_bases))
# define _LIBCPP_DECLSPEC_EMPTY_BASES __declspec(empty_bases)
#else
# define _LIBCPP_DECLSPEC_EMPTY_BASES
#endif
#if defined(_LIBCPP_ENABLE_CXX17_REMOVED_FEATURES)
#define _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
#define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
#define _LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
#define _LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS
#endif // _LIBCPP_ENABLE_CXX17_REMOVED_FEATURES
#if defined(_LIBCPP_ENABLE_CXX20_REMOVED_FEATURES)
#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
#define _LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS
#define _LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS
#define _LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR
#define _LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS
#endif // _LIBCPP_ENABLE_CXX20_REMOVED_FEATURES
#if !defined(__cpp_impl_coroutine) || __cpp_impl_coroutine < 201902L
#define _LIBCPP_HAS_NO_CXX20_COROUTINES
#endif
#if defined(_LIBCPP_COMPILER_IBM)
#define _LIBCPP_HAS_NO_PRAGMA_PUSH_POP_MACRO
#endif
#if defined(_LIBCPP_HAS_NO_PRAGMA_PUSH_POP_MACRO)
# define _LIBCPP_PUSH_MACROS
# define _LIBCPP_POP_MACROS
#else
// Don't warn about macro conflicts when we can restore them at the
// end of the header.
# ifndef _LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS
# define _LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS
# endif
# if defined(_LIBCPP_COMPILER_MSVC)
# define _LIBCPP_PUSH_MACROS \
__pragma(push_macro("min")) \
__pragma(push_macro("max"))
# define _LIBCPP_POP_MACROS \
__pragma(pop_macro("min")) \
__pragma(pop_macro("max"))
# else
# define _LIBCPP_PUSH_MACROS \
_Pragma("push_macro(\"min\")") \
_Pragma("push_macro(\"max\")")
# define _LIBCPP_POP_MACROS \
_Pragma("pop_macro(\"min\")") \
_Pragma("pop_macro(\"max\")")
# endif
#endif // defined(_LIBCPP_HAS_NO_PRAGMA_PUSH_POP_MACRO)
#ifndef _LIBCPP_NO_AUTO_LINK
# if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_BUILDING_LIBRARY)
# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
# pragma comment(lib, "c++.lib")
# else
# pragma comment(lib, "libc++.lib")
# endif
# endif // defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_BUILDING_LIBRARY)
#endif // _LIBCPP_NO_AUTO_LINK
// Configures the fopen close-on-exec mode character, if any. This string will
// be appended to any mode string used by fstream for fopen/fdopen.
//
// Not all platforms support this, but it helps avoid fd-leaks on platforms that
// do.
#if defined(__BIONIC__)
# define _LIBCPP_FOPEN_CLOEXEC_MODE "e"
#else
# define _LIBCPP_FOPEN_CLOEXEC_MODE
#endif
// Support for _FILE_OFFSET_BITS=64 landed gradually in Android, so the full set
// of functions used in cstdio may not be available for low API levels when
// using 64-bit file offsets on LP32.
#if defined(__BIONIC__) && defined(__USE_FILE_OFFSET64) && __ANDROID_API__ < 24
#define _LIBCPP_HAS_NO_FGETPOS_FSETPOS
#endif
#if __has_attribute(init_priority)
// TODO: Remove this once we drop support for building libc++ with old Clangs
# if (defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER < 1200) || \
(defined(__apple_build_version__) && __apple_build_version__ < 13000000)
# define _LIBCPP_INIT_PRIORITY_MAX __attribute__((init_priority(101)))
# else
# define _LIBCPP_INIT_PRIORITY_MAX __attribute__((init_priority(100)))
# endif
#else
# define _LIBCPP_INIT_PRIORITY_MAX
#endif
#if defined(__GNUC__) || defined(__clang__)
// The attribute uses 1-based indices for ordinary and static member functions.
// The attribute uses 2-based indices for non-static member functions.
# define _LIBCPP_ATTRIBUTE_FORMAT(archetype, format_string_index, first_format_arg_index) \
__attribute__((__format__(archetype, format_string_index, first_format_arg_index)))
#else
# define _LIBCPP_ATTRIBUTE_FORMAT(archetype, format_string_index, first_format_arg_index) /* nothing */
#endif
#endif // __cplusplus
#endif // _LIBCPP_CONFIG
diff --git a/contrib/llvm-project/libcxx/include/__iterator/distance.h b/contrib/llvm-project/libcxx/include/__iterator/distance.h
index faab03492389..85309f8d47d6 100644
--- a/contrib/llvm-project/libcxx/include/__iterator/distance.h
+++ b/contrib/llvm-project/libcxx/include/__iterator/distance.h
@@ -1,107 +1,107 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___ITERATOR_DISTANCE_H
#define _LIBCPP___ITERATOR_DISTANCE_H
#include <__config>
#include <__iterator/concepts.h>
#include <__iterator/incrementable_traits.h>
#include <__iterator/iterator_traits.h>
#include <__ranges/access.h>
#include <__ranges/concepts.h>
#include <__ranges/size.h>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
template <class _InputIter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
typename iterator_traits<_InputIter>::difference_type
__distance(_InputIter __first, _InputIter __last, input_iterator_tag)
{
typename iterator_traits<_InputIter>::difference_type __r(0);
for (; __first != __last; ++__first)
++__r;
return __r;
}
template <class _RandIter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
typename iterator_traits<_RandIter>::difference_type
__distance(_RandIter __first, _RandIter __last, random_access_iterator_tag)
{
return __last - __first;
}
template <class _InputIter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
typename iterator_traits<_InputIter>::difference_type
distance(_InputIter __first, _InputIter __last)
{
return _VSTD::__distance(__first, __last, typename iterator_traits<_InputIter>::iterator_category());
}
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [range.iter.op.distance]
namespace ranges {
namespace __distance {
struct __fn {
template<class _Ip, sentinel_for<_Ip> _Sp>
requires (!sized_sentinel_for<_Sp, _Ip>)
_LIBCPP_HIDE_FROM_ABI
constexpr iter_difference_t<_Ip> operator()(_Ip __first, _Sp __last) const {
iter_difference_t<_Ip> __n = 0;
while (__first != __last) {
++__first;
++__n;
}
return __n;
}
template<class _Ip, sized_sentinel_for<decay_t<_Ip>> _Sp>
_LIBCPP_HIDE_FROM_ABI
constexpr iter_difference_t<_Ip> operator()(_Ip&& __first, _Sp __last) const {
if constexpr (sized_sentinel_for<_Sp, __uncvref_t<_Ip>>) {
return __last - __first;
} else {
return __last - decay_t<_Ip>(__first);
}
}
template<range _Rp>
_LIBCPP_HIDE_FROM_ABI
constexpr range_difference_t<_Rp> operator()(_Rp&& __r) const {
if constexpr (sized_range<_Rp>) {
return static_cast<range_difference_t<_Rp>>(ranges::size(__r));
} else {
return operator()(ranges::begin(__r), ranges::end(__r));
}
}
};
} // namespace __distance
inline namespace __cpo {
inline constexpr auto distance = __distance::__fn{};
} // namespace __cpo
} // namespace ranges
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_DISTANCE_H
diff --git a/contrib/llvm-project/libcxx/include/__iterator/indirectly_comparable.h b/contrib/llvm-project/libcxx/include/__iterator/indirectly_comparable.h
index 3bafc56f926f..ad5ff1a866d6 100644
--- a/contrib/llvm-project/libcxx/include/__iterator/indirectly_comparable.h
+++ b/contrib/llvm-project/libcxx/include/__iterator/indirectly_comparable.h
@@ -1,30 +1,30 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___ITERATOR_INDIRECTLY_COMPARABLE_H
#define _LIBCPP___ITERATOR_INDIRECTLY_COMPARABLE_H
#include <__config>
#include <__functional/identity.h>
#include <__iterator/concepts.h>
#include <__iterator/projected.h>
_LIBCPP_BEGIN_NAMESPACE_STD
-#ifndef _LIBCPP_HAS_NO_CONCEPTS
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _I1, class _I2, class _Rp, class _P1 = identity, class _P2 = identity>
concept indirectly_comparable =
indirect_binary_predicate<_Rp, projected<_I1, _P1>, projected<_I2, _P2>>;
-#endif // _LIBCPP_HAS_NO_CONCEPTS
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_INDIRECTLY_COMPARABLE_H
diff --git a/contrib/llvm-project/libcxx/include/__iterator/insert_iterator.h b/contrib/llvm-project/libcxx/include/__iterator/insert_iterator.h
index 2f18f5f12162..d3cd5ad6f9c5 100644
--- a/contrib/llvm-project/libcxx/include/__iterator/insert_iterator.h
+++ b/contrib/llvm-project/libcxx/include/__iterator/insert_iterator.h
@@ -1,81 +1,81 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___ITERATOR_INSERT_ITERATOR_H
#define _LIBCPP___ITERATOR_INSERT_ITERATOR_H
#include <__config>
#include <__iterator/iterator.h>
#include <__iterator/iterator_traits.h>
#include <__memory/addressof.h>
#include <__ranges/access.h>
#include <__utility/move.h>
#include <cstddef>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _Container>
using __insert_iterator_iter_t = ranges::iterator_t<_Container>;
#else
template <class _Container>
using __insert_iterator_iter_t = typename _Container::iterator;
#endif
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Container>
class _LIBCPP_TEMPLATE_VIS insert_iterator
#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
: public iterator<output_iterator_tag, void, void, void, void>
#endif
{
_LIBCPP_SUPPRESS_DEPRECATED_POP
protected:
_Container* container;
__insert_iterator_iter_t<_Container> iter;
public:
typedef output_iterator_tag iterator_category;
typedef void value_type;
#if _LIBCPP_STD_VER > 17
typedef ptrdiff_t difference_type;
#else
typedef void difference_type;
#endif
typedef void pointer;
typedef void reference;
typedef _Container container_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator(_Container& __x, __insert_iterator_iter_t<_Container> __i)
: container(_VSTD::addressof(__x)), iter(__i) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(const typename _Container::value_type& __value_)
{iter = container->insert(iter, __value_); ++iter; return *this;}
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(typename _Container::value_type&& __value_)
{iter = container->insert(iter, _VSTD::move(__value_)); ++iter; return *this;}
#endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator*() {return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator++() {return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator++(int) {return *this;}
};
template <class _Container>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
insert_iterator<_Container>
inserter(_Container& __x, __insert_iterator_iter_t<_Container> __i)
{
return insert_iterator<_Container>(__x, __i);
}
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_INSERT_ITERATOR_H
diff --git a/contrib/llvm-project/libcxx/include/__iterator/reverse_iterator.h b/contrib/llvm-project/libcxx/include/__iterator/reverse_iterator.h
index 449eb529aa98..af855a0a1e73 100644
--- a/contrib/llvm-project/libcxx/include/__iterator/reverse_iterator.h
+++ b/contrib/llvm-project/libcxx/include/__iterator/reverse_iterator.h
@@ -1,235 +1,235 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___ITERATOR_REVERSE_ITERATOR_H
#define _LIBCPP___ITERATOR_REVERSE_ITERATOR_H
#include <__compare/compare_three_way_result.h>
#include <__compare/three_way_comparable.h>
#include <__config>
#include <__iterator/iterator.h>
#include <__iterator/iterator_traits.h>
#include <__memory/addressof.h>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Iter>
class _LIBCPP_TEMPLATE_VIS reverse_iterator
#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
: public iterator<typename iterator_traits<_Iter>::iterator_category,
typename iterator_traits<_Iter>::value_type,
typename iterator_traits<_Iter>::difference_type,
typename iterator_traits<_Iter>::pointer,
typename iterator_traits<_Iter>::reference>
#endif
{
_LIBCPP_SUPPRESS_DEPRECATED_POP
private:
#ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
_Iter __t; // no longer used as of LWG #2360, not removed due to ABI break
#endif
protected:
_Iter current;
public:
typedef _Iter iterator_type;
typedef typename iterator_traits<_Iter>::difference_type difference_type;
typedef typename iterator_traits<_Iter>::reference reference;
typedef typename iterator_traits<_Iter>::pointer pointer;
typedef _If<__is_cpp17_random_access_iterator<_Iter>::value,
random_access_iterator_tag,
typename iterator_traits<_Iter>::iterator_category> iterator_category;
typedef typename iterator_traits<_Iter>::value_type value_type;
#if _LIBCPP_STD_VER > 17
typedef _If<__is_cpp17_random_access_iterator<_Iter>::value,
random_access_iterator_tag,
bidirectional_iterator_tag> iterator_concept;
#endif
#ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reverse_iterator() : __t(), current() {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
explicit reverse_iterator(_Iter __x) : __t(__x), current(__x) {}
template <class _Up, class = __enable_if_t<
!is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reverse_iterator(const reverse_iterator<_Up>& __u)
: __t(__u.base()), current(__u.base())
{ }
template <class _Up, class = __enable_if_t<
!is_same<_Up, _Iter>::value &&
is_convertible<_Up const&, _Iter>::value &&
is_assignable<_Iter&, _Up const&>::value
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
__t = current = __u.base();
return *this;
}
#else
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reverse_iterator() : current() {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
explicit reverse_iterator(_Iter __x) : current(__x) {}
template <class _Up, class = __enable_if_t<
!is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reverse_iterator(const reverse_iterator<_Up>& __u)
: current(__u.base())
{ }
template <class _Up, class = __enable_if_t<
!is_same<_Up, _Iter>::value &&
is_convertible<_Up const&, _Iter>::value &&
is_assignable<_Iter&, _Up const&>::value
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
current = __u.base();
return *this;
}
#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
_Iter base() const {return current;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reference operator*() const {_Iter __tmp = current; return *--__tmp;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
pointer operator->() const {return _VSTD::addressof(operator*());}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reverse_iterator& operator++() {--current; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reverse_iterator operator++(int) {reverse_iterator __tmp(*this); --current; return __tmp;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reverse_iterator& operator--() {++current; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reverse_iterator operator--(int) {reverse_iterator __tmp(*this); ++current; return __tmp;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reverse_iterator operator+ (difference_type __n) const {return reverse_iterator(current - __n);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reverse_iterator& operator+=(difference_type __n) {current -= __n; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reverse_iterator operator- (difference_type __n) const {return reverse_iterator(current + __n);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reverse_iterator& operator-=(difference_type __n) {current += __n; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reference operator[](difference_type __n) const {return *(*this + __n);}
};
template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
bool
operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
{
return __x.base() == __y.base();
}
template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
bool
operator<(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
{
return __x.base() > __y.base();
}
template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
bool
operator!=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
{
return __x.base() != __y.base();
}
template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
bool
operator>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
{
return __x.base() < __y.base();
}
template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
bool
operator>=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
{
return __x.base() <= __y.base();
}
template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
bool
operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
{
return __x.base() >= __y.base();
}
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2>
_LIBCPP_HIDE_FROM_ABI constexpr
compare_three_way_result_t<_Iter1, _Iter2>
operator<=>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
{
return __y.base() <=> __x.base();
}
#endif
#ifndef _LIBCPP_CXX03_LANG
template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
auto
operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
-> decltype(__y.base() - __x.base())
{
return __y.base() - __x.base();
}
#else
template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY
typename reverse_iterator<_Iter1>::difference_type
operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
{
return __y.base() - __x.base();
}
#endif
template <class _Iter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reverse_iterator<_Iter>
operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x)
{
return reverse_iterator<_Iter>(__x.base() - __n);
}
#if _LIBCPP_STD_VER > 11
template <class _Iter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
reverse_iterator<_Iter> make_reverse_iterator(_Iter __i)
{
return reverse_iterator<_Iter>(__i);
}
#endif
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_REVERSE_ITERATOR_H
diff --git a/contrib/llvm-project/libcxx/include/__random/uniform_random_bit_generator.h b/contrib/llvm-project/libcxx/include/__random/uniform_random_bit_generator.h
index 7b2f0df868d7..8bcd20f42367 100644
--- a/contrib/llvm-project/libcxx/include/__random/uniform_random_bit_generator.h
+++ b/contrib/llvm-project/libcxx/include/__random/uniform_random_bit_generator.h
@@ -1,45 +1,45 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANDOM_UNIFORM_RANDOM_BIT_GENERATOR_H
#define _LIBCPP___RANDOM_UNIFORM_RANDOM_BIT_GENERATOR_H
#include <__concepts/arithmetic.h>
#include <__concepts/invocable.h>
#include <__concepts/same_as.h>
#include <__config>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_PUSH_MACROS
#include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [rand.req.urng]
template<class _Gen>
concept uniform_random_bit_generator =
invocable<_Gen&> && unsigned_integral<invoke_result_t<_Gen&>> &&
requires {
{ _Gen::min() } -> same_as<invoke_result_t<_Gen&>>;
{ _Gen::max() } -> same_as<invoke_result_t<_Gen&>>;
requires bool_constant<(_Gen::min() < _Gen::max())>::value;
};
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS
#endif // _LIBCPP___RANDOM_UNIFORM_RANDOM_BIT_GENERATOR_H
diff --git a/contrib/llvm-project/libcxx/include/__ranges/access.h b/contrib/llvm-project/libcxx/include/__ranges/access.h
index 67c6c57bd81e..07a92d783475 100644
--- a/contrib/llvm-project/libcxx/include/__ranges/access.h
+++ b/contrib/llvm-project/libcxx/include/__ranges/access.h
@@ -1,220 +1,227 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANGES_ACCESS_H
#define _LIBCPP___RANGES_ACCESS_H
#include <__concepts/class_or_enum.h>
#include <__config>
#include <__iterator/concepts.h>
#include <__iterator/readable_traits.h>
#include <__ranges/enable_borrowed_range.h>
#include <__utility/as_const.h>
#include <__utility/auto_cast.h>
#include <concepts>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
namespace ranges {
template <class _Tp>
concept __can_borrow =
is_lvalue_reference_v<_Tp> || enable_borrowed_range<remove_cvref_t<_Tp>>;
} // namespace ranges
// [range.access.begin]
namespace ranges {
namespace __begin {
template <class _Tp>
concept __member_begin =
__can_borrow<_Tp> &&
__workaround_52970<_Tp> &&
requires(_Tp&& __t) {
{ _LIBCPP_AUTO_CAST(__t.begin()) } -> input_or_output_iterator;
};
void begin(auto&) = delete;
void begin(const auto&) = delete;
template <class _Tp>
concept __unqualified_begin =
!__member_begin<_Tp> &&
__can_borrow<_Tp> &&
__class_or_enum<remove_cvref_t<_Tp>> &&
requires(_Tp && __t) {
{ _LIBCPP_AUTO_CAST(begin(__t)) } -> input_or_output_iterator;
};
struct __fn {
template <class _Tp>
- requires is_array_v<remove_cv_t<_Tp>>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp& __t) const noexcept
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[]) const noexcept
+ requires (sizeof(_Tp) != 0) // Disallow incomplete element types.
{
- return __t;
+ return __t + 0;
+ }
+
+ template <class _Tp, size_t _Np>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[_Np]) const noexcept
+ requires (sizeof(_Tp) != 0) // Disallow incomplete element types.
+ {
+ return __t + 0;
}
template <class _Tp>
requires __member_begin<_Tp>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.begin())))
{
return _LIBCPP_AUTO_CAST(__t.begin());
}
template <class _Tp>
requires __unqualified_begin<_Tp>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
noexcept(noexcept(_LIBCPP_AUTO_CAST(begin(__t))))
{
return _LIBCPP_AUTO_CAST(begin(__t));
}
void operator()(auto&&) const = delete;
};
} // namespace __begin
inline namespace __cpo {
inline constexpr auto begin = __begin::__fn{};
} // namespace __cpo
} // namespace ranges
// [range.range]
namespace ranges {
template <class _Tp>
using iterator_t = decltype(ranges::begin(declval<_Tp&>()));
} // namespace ranges
// [range.access.end]
namespace ranges {
namespace __end {
template <class _Tp>
concept __member_end =
__can_borrow<_Tp> &&
__workaround_52970<_Tp> &&
requires(_Tp&& __t) {
typename iterator_t<_Tp>;
{ _LIBCPP_AUTO_CAST(__t.end()) } -> sentinel_for<iterator_t<_Tp>>;
};
void end(auto&) = delete;
void end(const auto&) = delete;
template <class _Tp>
concept __unqualified_end =
!__member_end<_Tp> &&
__can_borrow<_Tp> &&
__class_or_enum<remove_cvref_t<_Tp>> &&
requires(_Tp && __t) {
typename iterator_t<_Tp>;
{ _LIBCPP_AUTO_CAST(end(__t)) } -> sentinel_for<iterator_t<_Tp>>;
};
class __fn {
public:
template <class _Tp, size_t _Np>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[_Np]) const noexcept
- requires (sizeof(*__t) != 0) // Disallow incomplete element types.
+ requires (sizeof(_Tp) != 0) // Disallow incomplete element types.
{
return __t + _Np;
}
template <class _Tp>
requires __member_end<_Tp>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.end())))
{
return _LIBCPP_AUTO_CAST(__t.end());
}
template <class _Tp>
requires __unqualified_end<_Tp>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
noexcept(noexcept(_LIBCPP_AUTO_CAST(end(__t))))
{
return _LIBCPP_AUTO_CAST(end(__t));
}
void operator()(auto&&) const = delete;
};
} // namespace __end
inline namespace __cpo {
inline constexpr auto end = __end::__fn{};
} // namespace __cpo
} // namespace ranges
// [range.access.cbegin]
namespace ranges {
namespace __cbegin {
struct __fn {
template <class _Tp>
requires is_lvalue_reference_v<_Tp&&>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
constexpr auto operator()(_Tp&& __t) const
noexcept(noexcept(ranges::begin(static_cast<const remove_reference_t<_Tp>&>(__t))))
-> decltype( ranges::begin(static_cast<const remove_reference_t<_Tp>&>(__t)))
{ return ranges::begin(static_cast<const remove_reference_t<_Tp>&>(__t)); }
template <class _Tp>
requires is_rvalue_reference_v<_Tp&&>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
constexpr auto operator()(_Tp&& __t) const
noexcept(noexcept(ranges::begin(static_cast<const _Tp&&>(__t))))
-> decltype( ranges::begin(static_cast<const _Tp&&>(__t)))
{ return ranges::begin(static_cast<const _Tp&&>(__t)); }
};
} // namespace __cbegin
inline namespace __cpo {
inline constexpr auto cbegin = __cbegin::__fn{};
} // namespace __cpo
} // namespace ranges
// [range.access.cend]
namespace ranges {
namespace __cend {
struct __fn {
template <class _Tp>
requires is_lvalue_reference_v<_Tp&&>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
constexpr auto operator()(_Tp&& __t) const
noexcept(noexcept(ranges::end(static_cast<const remove_reference_t<_Tp>&>(__t))))
-> decltype( ranges::end(static_cast<const remove_reference_t<_Tp>&>(__t)))
{ return ranges::end(static_cast<const remove_reference_t<_Tp>&>(__t)); }
template <class _Tp>
requires is_rvalue_reference_v<_Tp&&>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
constexpr auto operator()(_Tp&& __t) const
noexcept(noexcept(ranges::end(static_cast<const _Tp&&>(__t))))
-> decltype( ranges::end(static_cast<const _Tp&&>(__t)))
{ return ranges::end(static_cast<const _Tp&&>(__t)); }
};
} // namespace __cend
inline namespace __cpo {
inline constexpr auto cend = __cend::__fn{};
} // namespace __cpo
} // namespace ranges
#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_ACCESS_H
diff --git a/contrib/llvm-project/libcxx/include/__ranges/enable_borrowed_range.h b/contrib/llvm-project/libcxx/include/__ranges/enable_borrowed_range.h
index 5f5b3f505773..f9985dfd0061 100644
--- a/contrib/llvm-project/libcxx/include/__ranges/enable_borrowed_range.h
+++ b/contrib/llvm-project/libcxx/include/__ranges/enable_borrowed_range.h
@@ -1,41 +1,41 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANGES_ENABLE_BORROWED_RANGE_H
#define _LIBCPP___RANGES_ENABLE_BORROWED_RANGE_H
// These customization variables are used in <span> and <string_view>. The
// separate header is used to avoid including the entire <ranges> header in
// <span> and <string_view>.
#include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
namespace ranges
{
// [range.range], ranges
template <class>
inline constexpr bool enable_borrowed_range = false;
} // namespace ranges
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_ENABLE_BORROWED_RANGE_H
diff --git a/contrib/llvm-project/libcxx/include/__ranges/non_propagating_cache.h b/contrib/llvm-project/libcxx/include/__ranges/non_propagating_cache.h
index d0f447ce7cc5..2d3a9408713e 100644
--- a/contrib/llvm-project/libcxx/include/__ranges/non_propagating_cache.h
+++ b/contrib/llvm-project/libcxx/include/__ranges/non_propagating_cache.h
@@ -1,114 +1,114 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANGES_NON_PROPAGATING_CACHE_H
#define _LIBCPP___RANGES_NON_PROPAGATING_CACHE_H
#include <__config>
#include <__iterator/concepts.h> // indirectly_readable
#include <__iterator/iterator_traits.h> // iter_reference_t
#include <__memory/addressof.h>
#include <__utility/forward.h>
#include <concepts> // constructible_from
#include <optional>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
namespace ranges {
// __non_propagating_cache is a helper type that allows storing an optional value in it,
// but which does not copy the source's value when it is copy constructed/assigned to,
// and which resets the source's value when it is moved-from.
//
// This type is used as an implementation detail of some views that need to cache the
// result of `begin()` in order to provide an amortized O(1) begin() method. Typically,
// we don't want to propagate the value of the cache upon copy because the cached iterator
// may refer to internal details of the source view.
template<class _Tp>
requires is_object_v<_Tp>
class _LIBCPP_TEMPLATE_VIS __non_propagating_cache {
struct __from_tag { };
struct __forward_tag { };
// This helper class is needed to perform copy and move elision when
// constructing the contained type from an iterator.
struct __wrapper {
template<class ..._Args>
constexpr explicit __wrapper(__forward_tag, _Args&& ...__args) : __t_(_VSTD::forward<_Args>(__args)...) { }
template<class _Fn>
constexpr explicit __wrapper(__from_tag, _Fn const& __f) : __t_(__f()) { }
_Tp __t_;
};
optional<__wrapper> __value_ = nullopt;
public:
_LIBCPP_HIDE_FROM_ABI __non_propagating_cache() = default;
_LIBCPP_HIDE_FROM_ABI
constexpr __non_propagating_cache(__non_propagating_cache const&) noexcept
: __value_(nullopt)
{ }
_LIBCPP_HIDE_FROM_ABI
constexpr __non_propagating_cache(__non_propagating_cache&& __other) noexcept
: __value_(nullopt)
{
__other.__value_.reset();
}
_LIBCPP_HIDE_FROM_ABI
constexpr __non_propagating_cache& operator=(__non_propagating_cache const& __other) noexcept {
if (this != _VSTD::addressof(__other)) {
__value_.reset();
}
return *this;
}
_LIBCPP_HIDE_FROM_ABI
constexpr __non_propagating_cache& operator=(__non_propagating_cache&& __other) noexcept {
__value_.reset();
__other.__value_.reset();
return *this;
}
_LIBCPP_HIDE_FROM_ABI
constexpr _Tp& operator*() { return __value_->__t_; }
_LIBCPP_HIDE_FROM_ABI
constexpr _Tp const& operator*() const { return __value_->__t_; }
_LIBCPP_HIDE_FROM_ABI
constexpr bool __has_value() const { return __value_.has_value(); }
template<class _Fn>
_LIBCPP_HIDE_FROM_ABI
constexpr _Tp& __emplace_from(_Fn const& __f) {
return __value_.emplace(__from_tag{}, __f).__t_;
}
template<class ..._Args>
_LIBCPP_HIDE_FROM_ABI
constexpr _Tp& __emplace(_Args&& ...__args) {
return __value_.emplace(__forward_tag{}, _VSTD::forward<_Args>(__args)...).__t_;
}
};
struct __empty_cache { };
} // namespace ranges
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_NON_PROPAGATING_CACHE_H
diff --git a/contrib/llvm-project/libcxx/include/__utility/cmp.h b/contrib/llvm-project/libcxx/include/__utility/cmp.h
index 4fc96b054f4d..3889cc7492fa 100644
--- a/contrib/llvm-project/libcxx/include/__utility/cmp.h
+++ b/contrib/llvm-project/libcxx/include/__utility/cmp.h
@@ -1,110 +1,110 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___UTILITY_CMP_H
#define _LIBCPP___UTILITY_CMP_H
#include <__config>
#include <__utility/forward.h>
#include <__utility/move.h>
#include <limits>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_PUSH_MACROS
#include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template<class _Tp, class... _Up>
struct _IsSameAsAny : _Or<_IsSame<_Tp, _Up>...> {};
template<class _Tp>
concept __is_safe_integral_cmp = is_integral_v<_Tp> &&
!_IsSameAsAny<_Tp, bool, char
#ifndef _LIBCPP_HAS_NO_CHAR8_T
, char8_t
#endif
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
, char16_t, char32_t
#endif
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
, wchar_t
#endif
>::value;
template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
_LIBCPP_INLINE_VISIBILITY constexpr
bool cmp_equal(_Tp __t, _Up __u) noexcept
{
if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
return __t == __u;
else if constexpr (is_signed_v<_Tp>)
return __t < 0 ? false : make_unsigned_t<_Tp>(__t) == __u;
else
return __u < 0 ? false : __t == make_unsigned_t<_Up>(__u);
}
template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
_LIBCPP_INLINE_VISIBILITY constexpr
bool cmp_not_equal(_Tp __t, _Up __u) noexcept
{
return !_VSTD::cmp_equal(__t, __u);
}
template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
_LIBCPP_INLINE_VISIBILITY constexpr
bool cmp_less(_Tp __t, _Up __u) noexcept
{
if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
return __t < __u;
else if constexpr (is_signed_v<_Tp>)
return __t < 0 ? true : make_unsigned_t<_Tp>(__t) < __u;
else
return __u < 0 ? false : __t < make_unsigned_t<_Up>(__u);
}
template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
_LIBCPP_INLINE_VISIBILITY constexpr
bool cmp_greater(_Tp __t, _Up __u) noexcept
{
return _VSTD::cmp_less(__u, __t);
}
template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
_LIBCPP_INLINE_VISIBILITY constexpr
bool cmp_less_equal(_Tp __t, _Up __u) noexcept
{
return !_VSTD::cmp_greater(__t, __u);
}
template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
_LIBCPP_INLINE_VISIBILITY constexpr
bool cmp_greater_equal(_Tp __t, _Up __u) noexcept
{
return !_VSTD::cmp_less(__t, __u);
}
template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
_LIBCPP_INLINE_VISIBILITY constexpr
bool in_range(_Up __u) noexcept
{
return _VSTD::cmp_less_equal(__u, numeric_limits<_Tp>::max()) &&
_VSTD::cmp_greater_equal(__u, numeric_limits<_Tp>::min());
}
#endif
_LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS
#endif // _LIBCPP___UTILITY_CMP_H
diff --git a/contrib/llvm-project/libcxx/include/__utility/pair.h b/contrib/llvm-project/libcxx/include/__utility/pair.h
index f1114696884a..82e82eabf832 100644
--- a/contrib/llvm-project/libcxx/include/__utility/pair.h
+++ b/contrib/llvm-project/libcxx/include/__utility/pair.h
@@ -1,609 +1,609 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___UTILITY_PAIR_H
#define _LIBCPP___UTILITY_PAIR_H
#include <__compare/common_comparison_category.h>
#include <__compare/synth_three_way.h>
#include <__config>
#include <__functional/unwrap_ref.h>
#include <__tuple>
#include <__utility/forward.h>
#include <__utility/move.h>
#include <__utility/piecewise_construct.h>
#include <cstddef>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
template <class, class>
struct __non_trivially_copyable_base {
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
__non_trivially_copyable_base() _NOEXCEPT {}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
__non_trivially_copyable_base(__non_trivially_copyable_base const&) _NOEXCEPT {}
};
#endif
template <class _T1, class _T2>
struct _LIBCPP_TEMPLATE_VIS pair
#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
: private __non_trivially_copyable_base<_T1, _T2>
#endif
{
typedef _T1 first_type;
typedef _T2 second_type;
_T1 first;
_T2 second;
#if !defined(_LIBCPP_CXX03_LANG)
pair(pair const&) = default;
pair(pair&&) = default;
#else
// Use the implicitly declared copy constructor in C++03
#endif
#ifdef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
pair() : first(), second() {}
_LIBCPP_INLINE_VISIBILITY
pair(_T1 const& __t1, _T2 const& __t2) : first(__t1), second(__t2) {}
template <class _U1, class _U2>
_LIBCPP_INLINE_VISIBILITY
pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {}
_LIBCPP_INLINE_VISIBILITY
pair& operator=(pair const& __p) {
first = __p.first;
second = __p.second;
return *this;
}
#else
struct _CheckArgs {
template <int&...>
static constexpr bool __enable_explicit_default() {
return is_default_constructible<_T1>::value
&& is_default_constructible<_T2>::value
&& !__enable_implicit_default<>();
}
template <int&...>
static constexpr bool __enable_implicit_default() {
return __is_implicitly_default_constructible<_T1>::value
&& __is_implicitly_default_constructible<_T2>::value;
}
template <class _U1, class _U2>
static constexpr bool __enable_explicit() {
return is_constructible<first_type, _U1>::value
&& is_constructible<second_type, _U2>::value
&& (!is_convertible<_U1, first_type>::value
|| !is_convertible<_U2, second_type>::value);
}
template <class _U1, class _U2>
static constexpr bool __enable_implicit() {
return is_constructible<first_type, _U1>::value
&& is_constructible<second_type, _U2>::value
&& is_convertible<_U1, first_type>::value
&& is_convertible<_U2, second_type>::value;
}
};
template <bool _MaybeEnable>
using _CheckArgsDep _LIBCPP_NODEBUG = typename conditional<
_MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>::type;
struct _CheckTupleLikeConstructor {
template <class _Tuple>
static constexpr bool __enable_implicit() {
return __tuple_convertible<_Tuple, pair>::value;
}
template <class _Tuple>
static constexpr bool __enable_explicit() {
return __tuple_constructible<_Tuple, pair>::value
&& !__tuple_convertible<_Tuple, pair>::value;
}
template <class _Tuple>
static constexpr bool __enable_assign() {
return __tuple_assignable<_Tuple, pair>::value;
}
};
template <class _Tuple>
using _CheckTLC _LIBCPP_NODEBUG = typename conditional<
__tuple_like_with_size<_Tuple, 2>::value
&& !is_same<typename decay<_Tuple>::type, pair>::value,
_CheckTupleLikeConstructor,
__check_tuple_constructor_fail
>::type;
template<bool _Dummy = true, typename enable_if<
_CheckArgsDep<_Dummy>::__enable_explicit_default()
>::type* = nullptr>
explicit _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value &&
is_nothrow_default_constructible<second_type>::value)
: first(), second() {}
template<bool _Dummy = true, typename enable_if<
_CheckArgsDep<_Dummy>::__enable_implicit_default()
>::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value &&
is_nothrow_default_constructible<second_type>::value)
: first(), second() {}
template <bool _Dummy = true, typename enable_if<
_CheckArgsDep<_Dummy>::template __enable_explicit<_T1 const&, _T2 const&>()
>::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit pair(_T1 const& __t1, _T2 const& __t2)
_NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
is_nothrow_copy_constructible<second_type>::value)
: first(__t1), second(__t2) {}
template<bool _Dummy = true, typename enable_if<
_CheckArgsDep<_Dummy>::template __enable_implicit<_T1 const&, _T2 const&>()
>::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
pair(_T1 const& __t1, _T2 const& __t2)
_NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
is_nothrow_copy_constructible<second_type>::value)
: first(__t1), second(__t2) {}
template <
#if _LIBCPP_STD_VER > 20 // http://wg21.link/P1951
class _U1 = _T1, class _U2 = _T2,
#else
class _U1, class _U2,
#endif
typename enable_if<_CheckArgs::template __enable_explicit<_U1, _U2>()>::type* = nullptr
>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit pair(_U1&& __u1, _U2&& __u2)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value &&
is_nothrow_constructible<second_type, _U2>::value))
: first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}
template <
#if _LIBCPP_STD_VER > 20 // http://wg21.link/P1951
class _U1 = _T1, class _U2 = _T2,
#else
class _U1, class _U2,
#endif
typename enable_if<_CheckArgs::template __enable_implicit<_U1, _U2>()>::type* = nullptr
>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
pair(_U1&& __u1, _U2&& __u2)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value &&
is_nothrow_constructible<second_type, _U2>::value))
: first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}
template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>()
>::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit pair(pair<_U1, _U2> const& __p)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
is_nothrow_constructible<second_type, _U2 const&>::value))
: first(__p.first), second(__p.second) {}
template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>()
>::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
pair(pair<_U1, _U2> const& __p)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
is_nothrow_constructible<second_type, _U2 const&>::value))
: first(__p.first), second(__p.second) {}
template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_explicit<_U1, _U2>()
>::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit pair(pair<_U1, _U2>&&__p)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
is_nothrow_constructible<second_type, _U2&&>::value))
: first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_implicit<_U1, _U2>()
>::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
pair(pair<_U1, _U2>&& __p)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
is_nothrow_constructible<second_type, _U2&&>::value))
: first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
template<class _Tuple, typename enable_if<
_CheckTLC<_Tuple>::template __enable_explicit<_Tuple>()
>::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit pair(_Tuple&& __p)
: first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}
template<class _Tuple, typename enable_if<
_CheckTLC<_Tuple>::template __enable_implicit<_Tuple>()
>::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
pair(_Tuple&& __p)
: first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}
template <class... _Args1, class... _Args2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
pair(piecewise_construct_t __pc,
tuple<_Args1...> __first_args, tuple<_Args2...> __second_args)
_NOEXCEPT_((is_nothrow_constructible<first_type, _Args1...>::value &&
is_nothrow_constructible<second_type, _Args2...>::value))
: pair(__pc, __first_args, __second_args,
typename __make_tuple_indices<sizeof...(_Args1)>::type(),
typename __make_tuple_indices<sizeof...(_Args2) >::type()) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
pair& operator=(typename conditional<
is_copy_assignable<first_type>::value &&
is_copy_assignable<second_type>::value,
pair, __nat>::type const& __p)
_NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value &&
is_nothrow_copy_assignable<second_type>::value)
{
first = __p.first;
second = __p.second;
return *this;
}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
pair& operator=(typename conditional<
is_move_assignable<first_type>::value &&
is_move_assignable<second_type>::value,
pair, __nat>::type&& __p)
_NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
is_nothrow_move_assignable<second_type>::value)
{
first = _VSTD::forward<first_type>(__p.first);
second = _VSTD::forward<second_type>(__p.second);
return *this;
}
template <class _Tuple, typename enable_if<
_CheckTLC<_Tuple>::template __enable_assign<_Tuple>()
>::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
pair& operator=(_Tuple&& __p) {
first = _VSTD::get<0>(_VSTD::forward<_Tuple>(__p));
second = _VSTD::get<1>(_VSTD::forward<_Tuple>(__p));
return *this;
}
#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
void
swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value &&
__is_nothrow_swappable<second_type>::value)
{
using _VSTD::swap;
swap(first, __p.first);
swap(second, __p.second);
}
private:
#ifndef _LIBCPP_CXX03_LANG
template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
pair(piecewise_construct_t,
tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
__tuple_indices<_I1...>, __tuple_indices<_I2...>);
#endif
};
#if _LIBCPP_STD_VER >= 17
template<class _T1, class _T2>
pair(_T1, _T2) -> pair<_T1, _T2>;
#endif
// [pairs.spec], specialized algorithms
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
operator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{
return __x.first == __y.first && __x.second == __y.second;
}
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _T1, class _T2>
_LIBCPP_HIDE_FROM_ABI constexpr
common_comparison_category_t<
__synth_three_way_result<_T1>,
__synth_three_way_result<_T2> >
operator<=>(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{
if (auto __c = _VSTD::__synth_three_way(__x.first, __y.first); __c != 0) {
return __c;
}
return _VSTD::__synth_three_way(__x.second, __y.second);
}
-#else // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#else // !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
operator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{
return !(__x == __y);
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
operator< (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{
return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second);
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
operator> (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{
return __y < __x;
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
operator>=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{
return !(__x < __y);
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{
return !(__y < __x);
}
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
typename enable_if
<
__is_swappable<_T1>::value &&
__is_swappable<_T2>::value,
void
>::type
swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
_NOEXCEPT_((__is_nothrow_swappable<_T1>::value &&
__is_nothrow_swappable<_T2>::value))
{
__x.swap(__y);
}
#ifndef _LIBCPP_CXX03_LANG
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
make_pair(_T1&& __t1, _T2&& __t2)
{
return pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
(_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2));
}
#else // _LIBCPP_CXX03_LANG
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
pair<_T1,_T2>
make_pair(_T1 __x, _T2 __y)
{
return pair<_T1, _T2>(__x, __y);
}
#endif // _LIBCPP_CXX03_LANG
template <class _T1, class _T2>
struct _LIBCPP_TEMPLATE_VIS tuple_size<pair<_T1, _T2> >
: public integral_constant<size_t, 2> {};
template <size_t _Ip, class _T1, class _T2>
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, pair<_T1, _T2> >
{
static_assert(_Ip < 2, "Index out of bounds in std::tuple_element<std::pair<T1, T2>>");
};
template <class _T1, class _T2>
struct _LIBCPP_TEMPLATE_VIS tuple_element<0, pair<_T1, _T2> >
{
typedef _LIBCPP_NODEBUG _T1 type;
};
template <class _T1, class _T2>
struct _LIBCPP_TEMPLATE_VIS tuple_element<1, pair<_T1, _T2> >
{
typedef _LIBCPP_NODEBUG _T2 type;
};
template <size_t _Ip> struct __get_pair;
template <>
struct __get_pair<0>
{
template <class _T1, class _T2>
static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
_T1&
get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
template <class _T1, class _T2>
static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
const _T1&
get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
#ifndef _LIBCPP_CXX03_LANG
template <class _T1, class _T2>
static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
_T1&&
get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T1>(__p.first);}
template <class _T1, class _T2>
static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
const _T1&&
get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T1>(__p.first);}
#endif // _LIBCPP_CXX03_LANG
};
template <>
struct __get_pair<1>
{
template <class _T1, class _T2>
static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
_T2&
get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
template <class _T1, class _T2>
static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
const _T2&
get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
#ifndef _LIBCPP_CXX03_LANG
template <class _T1, class _T2>
static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
_T2&&
get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T2>(__p.second);}
template <class _T1, class _T2>
static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
const _T2&&
get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T2>(__p.second);}
#endif // _LIBCPP_CXX03_LANG
};
template <size_t _Ip, class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
typename tuple_element<_Ip, pair<_T1, _T2> >::type&
get(pair<_T1, _T2>& __p) _NOEXCEPT
{
return __get_pair<_Ip>::get(__p);
}
template <size_t _Ip, class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
get(const pair<_T1, _T2>& __p) _NOEXCEPT
{
return __get_pair<_Ip>::get(__p);
}
#ifndef _LIBCPP_CXX03_LANG
template <size_t _Ip, class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
get(pair<_T1, _T2>&& __p) _NOEXCEPT
{
return __get_pair<_Ip>::get(_VSTD::move(__p));
}
template <size_t _Ip, class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
get(const pair<_T1, _T2>&& __p) _NOEXCEPT
{
return __get_pair<_Ip>::get(_VSTD::move(__p));
}
#endif // _LIBCPP_CXX03_LANG
#if _LIBCPP_STD_VER > 11
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1 & get(pair<_T1, _T2>& __p) _NOEXCEPT
{
return __get_pair<0>::get(__p);
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1 const & get(pair<_T1, _T2> const& __p) _NOEXCEPT
{
return __get_pair<0>::get(__p);
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1 && get(pair<_T1, _T2>&& __p) _NOEXCEPT
{
return __get_pair<0>::get(_VSTD::move(__p));
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1 const && get(pair<_T1, _T2> const&& __p) _NOEXCEPT
{
return __get_pair<0>::get(_VSTD::move(__p));
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1 & get(pair<_T2, _T1>& __p) _NOEXCEPT
{
return __get_pair<1>::get(__p);
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1 const & get(pair<_T2, _T1> const& __p) _NOEXCEPT
{
return __get_pair<1>::get(__p);
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1 && get(pair<_T2, _T1>&& __p) _NOEXCEPT
{
return __get_pair<1>::get(_VSTD::move(__p));
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1 const && get(pair<_T2, _T1> const&& __p) _NOEXCEPT
{
return __get_pair<1>::get(_VSTD::move(__p));
}
#endif
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___UTILITY_PAIR_H
diff --git a/contrib/llvm-project/libcxx/include/module.modulemap b/contrib/llvm-project/libcxx/include/module.modulemap
index 84abf01bf5d7..749c17f8bc08 100644
--- a/contrib/llvm-project/libcxx/include/module.modulemap
+++ b/contrib/llvm-project/libcxx/include/module.modulemap
@@ -1,1090 +1,1091 @@
// define the module for __config outside of the top level 'std' module
// since __config may be included from C headers which may create an
// include cycle.
module std_config [system] [extern_c] {
- header "__config"
+ textual header "__config"
+ textual header "__config_site"
}
module std [system] {
export std_config
// FIXME: The standard does not require that each of these submodules
// re-exports its imported modules. We should provide an alternative form of
// export that issues a warning if a name from the submodule is used, and
// use that to provide a 'strict mode' for libc++.
// Deprecated C-compatibility headers. These can all be included from within
// an 'extern "C"' context.
module depr [extern_c] {
// <assert.h> provided by C library.
module ctype_h {
header "ctype.h"
export *
}
module errno_h {
header "errno.h"
export *
}
module fenv_h {
header "fenv.h"
export *
}
// <float.h> provided by compiler or C library.
module inttypes_h {
header "inttypes.h"
export stdint_h
export *
}
// <iso646.h> provided by compiler.
// <limits.h> provided by compiler or C library.
module locale_h {
header "locale.h"
export *
}
module math_h {
header "math.h"
export *
}
module setjmp_h {
header "setjmp.h"
export *
}
// FIXME: <stdalign.h> is missing.
// <signal.h> provided by C library.
// <stdarg.h> provided by compiler.
// <stdbool.h> provided by compiler.
module stddef_h {
// <stddef.h>'s __need_* macros require textual inclusion.
textual header "stddef.h"
}
module stdint_h {
header "stdint.h"
export *
// FIXME: This module only exists on OS X and for some reason the
// wildcard above doesn't export it.
export Darwin.C.stdint
}
module stdio_h {
// <stdio.h>'s __need_* macros require textual inclusion.
textual header "stdio.h"
export *
export Darwin.C.stdio
}
module stdlib_h {
// <stdlib.h>'s __need_* macros require textual inclusion.
textual header "stdlib.h"
export *
}
module string_h {
header "string.h"
export *
}
// FIXME: <uchar.h> is missing.
// <time.h> provided by C library.
module wchar_h {
// <wchar.h>'s __need_* macros require textual inclusion.
textual header "wchar.h"
export *
}
module wctype_h {
header "wctype.h"
export *
}
}
// <complex.h> and <tgmath.h> are not C headers in any real sense, do not
// allow their use in extern "C" contexts.
module complex_h {
header "complex.h"
export ccomplex
export *
}
module tgmath_h {
header "tgmath.h"
export ccomplex
export cmath
export *
}
// C compatibility headers.
module compat {
module cassert {
// <cassert>'s use of NDEBUG requires textual inclusion.
textual header "cassert"
}
module ccomplex {
header "ccomplex"
export complex
export *
}
module cctype {
header "cctype"
export *
}
module cerrno {
header "cerrno"
export *
}
module cfenv {
header "cfenv"
export *
}
module cfloat {
header "cfloat"
export *
}
module cinttypes {
header "cinttypes"
export cstdint
export *
}
module ciso646 {
header "ciso646"
export *
}
module climits {
header "climits"
export *
}
module clocale {
header "clocale"
export *
}
module cmath {
header "cmath"
export *
}
module csetjmp {
header "csetjmp"
export *
}
module csignal {
header "csignal"
export *
}
// FIXME: <cstdalign> is missing.
module cstdarg {
header "cstdarg"
export *
}
module cstdbool {
header "cstdbool"
export *
}
module cstddef {
header "cstddef"
export *
}
module cstdint {
header "cstdint"
export depr.stdint_h
export *
}
module cstdio {
header "cstdio"
export *
}
module cstdlib {
header "cstdlib"
export *
}
module cstring {
header "cstring"
export *
}
module ctgmath {
header "ctgmath"
export ccomplex
export cmath
export *
}
module ctime {
header "ctime"
export *
}
// FIXME: <cuchar> is missing.
module cwchar {
header "cwchar"
export depr.stdio_h
export *
}
module cwctype {
header "cwctype"
export *
}
}
module algorithm {
header "algorithm"
export initializer_list
export *
module __algorithm {
module adjacent_find { private header "__algorithm/adjacent_find.h" }
module all_of { private header "__algorithm/all_of.h" }
module any_of { private header "__algorithm/any_of.h" }
module binary_search { private header "__algorithm/binary_search.h" }
module clamp { private header "__algorithm/clamp.h" }
module comp { private header "__algorithm/comp.h" }
module comp_ref_type { private header "__algorithm/comp_ref_type.h" }
module copy { private header "__algorithm/copy.h" }
module copy_backward { private header "__algorithm/copy_backward.h" }
module copy_if { private header "__algorithm/copy_if.h" }
module copy_n { private header "__algorithm/copy_n.h" }
module count { private header "__algorithm/count.h" }
module count_if { private header "__algorithm/count_if.h" }
module equal { private header "__algorithm/equal.h" }
module equal_range { private header "__algorithm/equal_range.h" }
module fill { private header "__algorithm/fill.h" }
module fill_n { private header "__algorithm/fill_n.h" }
module find { private header "__algorithm/find.h" }
module find_end { private header "__algorithm/find_end.h" }
module find_first_of { private header "__algorithm/find_first_of.h" }
module find_if { private header "__algorithm/find_if.h" }
module find_if_not { private header "__algorithm/find_if_not.h" }
module for_each { private header "__algorithm/for_each.h" }
module for_each_n { private header "__algorithm/for_each_n.h" }
module generate { private header "__algorithm/generate.h" }
module generate_n { private header "__algorithm/generate_n.h" }
module half_positive { private header "__algorithm/half_positive.h" }
module in_in_out_result { private header "__algorithm/in_in_out_result.h" }
module in_in_result { private header "__algorithm/in_in_result.h" }
module in_out_result { private header "__algorithm/in_out_result.h" }
module includes { private header "__algorithm/includes.h" }
module inplace_merge { private header "__algorithm/inplace_merge.h" }
module is_heap { private header "__algorithm/is_heap.h" }
module is_heap_until { private header "__algorithm/is_heap_until.h" }
module is_partitioned { private header "__algorithm/is_partitioned.h" }
module is_permutation { private header "__algorithm/is_permutation.h" }
module is_sorted { private header "__algorithm/is_sorted.h" }
module is_sorted_until { private header "__algorithm/is_sorted_until.h" }
module iter_swap { private header "__algorithm/iter_swap.h" }
module lexicographical_compare { private header "__algorithm/lexicographical_compare.h" }
module lower_bound { private header "__algorithm/lower_bound.h" }
module make_heap { private header "__algorithm/make_heap.h" }
module max { private header "__algorithm/max.h" }
module max_element { private header "__algorithm/max_element.h" }
module merge { private header "__algorithm/merge.h" }
module min { private header "__algorithm/min.h" }
module min_element { private header "__algorithm/min_element.h" }
module minmax { private header "__algorithm/minmax.h" }
module minmax_element { private header "__algorithm/minmax_element.h" }
module mismatch { private header "__algorithm/mismatch.h" }
module move { private header "__algorithm/move.h" }
module move_backward { private header "__algorithm/move_backward.h" }
module next_permutation { private header "__algorithm/next_permutation.h" }
module none_of { private header "__algorithm/none_of.h" }
module nth_element { private header "__algorithm/nth_element.h" }
module partial_sort { private header "__algorithm/partial_sort.h" }
module partial_sort_copy { private header "__algorithm/partial_sort_copy.h" }
module partition { private header "__algorithm/partition.h" }
module partition_copy { private header "__algorithm/partition_copy.h" }
module partition_point { private header "__algorithm/partition_point.h" }
module pop_heap { private header "__algorithm/pop_heap.h" }
module prev_permutation { private header "__algorithm/prev_permutation.h" }
module push_heap { private header "__algorithm/push_heap.h" }
module remove { private header "__algorithm/remove.h" }
module remove_copy { private header "__algorithm/remove_copy.h" }
module remove_copy_if { private header "__algorithm/remove_copy_if.h" }
module remove_if { private header "__algorithm/remove_if.h" }
module replace { private header "__algorithm/replace.h" }
module replace_copy { private header "__algorithm/replace_copy.h" }
module replace_copy_if { private header "__algorithm/replace_copy_if.h" }
module replace_if { private header "__algorithm/replace_if.h" }
module reverse { private header "__algorithm/reverse.h" }
module reverse_copy { private header "__algorithm/reverse_copy.h" }
module rotate { private header "__algorithm/rotate.h" }
module rotate_copy { private header "__algorithm/rotate_copy.h" }
module sample { private header "__algorithm/sample.h" }
module search { private header "__algorithm/search.h" }
module search_n { private header "__algorithm/search_n.h" }
module set_difference { private header "__algorithm/set_difference.h" }
module set_intersection { private header "__algorithm/set_intersection.h" }
module set_symmetric_difference { private header "__algorithm/set_symmetric_difference.h" }
module set_union { private header "__algorithm/set_union.h" }
module shift_left { private header "__algorithm/shift_left.h" }
module shift_right { private header "__algorithm/shift_right.h" }
module shuffle { private header "__algorithm/shuffle.h" }
module sift_down { private header "__algorithm/sift_down.h" }
module sort { private header "__algorithm/sort.h" }
module sort_heap { private header "__algorithm/sort_heap.h" }
module stable_partition { private header "__algorithm/stable_partition.h" }
module stable_sort { private header "__algorithm/stable_sort.h" }
module swap_ranges { private header "__algorithm/swap_ranges.h" }
module transform { private header "__algorithm/transform.h" }
module unique { private header "__algorithm/unique.h" }
module unique_copy { private header "__algorithm/unique_copy.h" }
module unwrap_iter { private header "__algorithm/unwrap_iter.h" }
module upper_bound { private header "__algorithm/upper_bound.h" }
}
}
module any {
header "any"
export *
}
module array {
header "array"
export initializer_list
export *
}
module atomic {
header "atomic"
export *
}
module barrier {
requires cplusplus14
header "barrier"
export *
}
module bit {
header "bit"
export *
module __bit {
module bit_cast { private header "__bit/bit_cast.h" }
module byteswap { private header "__bit/byteswap.h" }
}
}
module bitset {
header "bitset"
export string
export iosfwd
export *
}
// No submodule for cassert. It fundamentally needs repeated, textual inclusion.
module charconv {
header "charconv"
export *
module __charconv {
module chars_format { private header "__charconv/chars_format.h" }
module from_chars_result { private header "__charconv/from_chars_result.h" }
module to_chars_result { private header "__charconv/to_chars_result.h" }
}
}
module chrono {
header "chrono"
export *
module __chrono {
module calendar { private header "__chrono/calendar.h" }
module convert_to_timespec { private header "__chrono/convert_to_timespec.h" }
module duration { private header "__chrono/duration.h" }
module file_clock { private header "__chrono/file_clock.h" }
module high_resolution_clock { private header "__chrono/high_resolution_clock.h" }
module steady_clock { private header "__chrono/steady_clock.h" }
module system_clock { private header "__chrono/system_clock.h" }
module time_point { private header "__chrono/time_point.h" }
}
}
module codecvt {
header "codecvt"
export *
}
module compare {
header "compare"
export *
module __compare {
module common_comparison_category { private header "__compare/common_comparison_category.h" }
module compare_partial_order_fallback { private header "__compare/compare_partial_order_fallback.h" }
module compare_strong_order_fallback { private header "__compare/compare_strong_order_fallback.h" }
module compare_three_way { private header "__compare/compare_three_way.h" }
module compare_three_way_result { private header "__compare/compare_three_way_result.h" }
module compare_weak_order_fallback { private header "__compare/compare_weak_order_fallback.h" }
module is_eq { private header "__compare/is_eq.h" }
module ordering { private header "__compare/ordering.h" }
module partial_order { private header "__compare/partial_order.h" }
module strong_order { private header "__compare/strong_order.h" }
module synth_three_way { private header "__compare/synth_three_way.h" }
module three_way_comparable { private header "__compare/three_way_comparable.h" }
module weak_order { private header "__compare/weak_order.h" }
}
}
module complex {
header "complex"
export *
}
module concepts {
header "concepts"
export *
module __concepts {
module arithmetic { private header "__concepts/arithmetic.h" }
module assignable { private header "__concepts/assignable.h" }
module boolean_testable { private header "__concepts/boolean_testable.h" }
module class_or_enum { private header "__concepts/class_or_enum.h" }
module common_reference_with { private header "__concepts/common_reference_with.h" }
module common_with { private header "__concepts/common_with.h" }
module constructible { private header "__concepts/constructible.h" }
module convertible_to { private header "__concepts/convertible_to.h" }
module copyable { private header "__concepts/copyable.h" }
module derived_from { private header "__concepts/derived_from.h" }
module destructible { private header "__concepts/destructible.h" }
module different_from { private header "__concepts/different_from.h" }
module equality_comparable { private header "__concepts/equality_comparable.h" }
module invocable { private header "__concepts/invocable.h" }
module movable { private header "__concepts/movable.h" }
module predicate { private header "__concepts/predicate.h" }
module regular { private header "__concepts/regular.h" }
module relation { private header "__concepts/relation.h" }
module same_as { private header "__concepts/same_as.h" }
module semiregular { private header "__concepts/semiregular.h" }
module swappable { private header "__concepts/swappable.h" }
module totally_ordered { private header "__concepts/totally_ordered.h" }
}
}
module condition_variable {
header "condition_variable"
export *
}
module coroutine {
requires coroutines
header "coroutine"
export compare
export *
module __coroutine {
module coroutine_handle { private header "__coroutine/coroutine_handle.h" }
module coroutine_traits { private header "__coroutine/coroutine_traits.h" }
module noop_coroutine_handle { private header "__coroutine/noop_coroutine_handle.h" }
module trivial_awaitables { private header "__coroutine/trivial_awaitables.h" }
}
}
module deque {
header "deque"
export initializer_list
export *
}
module exception {
header "exception"
export *
}
module execution {
header "execution"
export *
}
module filesystem {
header "filesystem"
export *
module __filesystem {
module copy_options { private header "__filesystem/copy_options.h" }
module directory_entry { private header "__filesystem/directory_entry.h" }
module directory_iterator { private header "__filesystem/directory_iterator.h" }
module directory_options { private header "__filesystem/directory_options.h" }
module file_status { private header "__filesystem/file_status.h" }
module file_time_type { private header "__filesystem/file_time_type.h" }
module file_type { private header "__filesystem/file_type.h" }
module filesystem_error { private header "__filesystem/filesystem_error.h" }
module operations { private header "__filesystem/operations.h" }
module path { private header "__filesystem/path.h" }
module path_iterator { private header "__filesystem/path_iterator.h" }
module perm_options { private header "__filesystem/perm_options.h" }
module perms { private header "__filesystem/perms.h" }
module recursive_directory_iterator { private header "__filesystem/recursive_directory_iterator.h" }
module space_info { private header "__filesystem/space_info.h" }
module u8path { private header "__filesystem/u8path.h" }
}
}
module format {
header "format"
export *
module __format {
module format_arg { private header "__format/format_arg.h" }
module format_args { private header "__format/format_args.h" }
module format_context {
private header "__format/format_context.h"
export optional
export locale
}
module format_error { private header "__format/format_error.h" }
module format_fwd { private header "__format/format_fwd.h" }
module format_parse_context { private header "__format/format_parse_context.h" }
module format_string { private header "__format/format_string.h" }
module format_to_n_result { private header "__format/format_to_n_result.h" }
module formatter { private header "__format/formatter.h" }
module formatter_bool { private header "__format/formatter_bool.h" }
module formatter_char { private header "__format/formatter_char.h" }
module formatter_floating_point { private header "__format/formatter_floating_point.h" }
module formatter_integer { private header "__format/formatter_integer.h" }
module formatter_integral { private header "__format/formatter_integral.h" }
module formatter_pointer { private header "__format/formatter_pointer.h" }
module formatter_string { private header "__format/formatter_string.h" }
module parser_std_format_spec { private header "__format/parser_std_format_spec.h" }
}
}
module forward_list {
header "forward_list"
export initializer_list
export *
}
module fstream {
header "fstream"
export *
}
module functional {
header "functional"
export *
module __functional {
module binary_function { private header "__functional/binary_function.h" }
module binary_negate { private header "__functional/binary_negate.h" }
module bind { private header "__functional/bind.h" }
module bind_back { private header "__functional/bind_back.h" }
module bind_front { private header "__functional/bind_front.h" }
module binder1st { private header "__functional/binder1st.h" }
module binder2nd { private header "__functional/binder2nd.h" }
module compose { private header "__functional/compose.h" }
module default_searcher { private header "__functional/default_searcher.h" }
module function { private header "__functional/function.h" }
module hash { private header "__functional/hash.h" }
module identity { private header "__functional/identity.h" }
module invoke { private header "__functional/invoke.h" }
module is_transparent { private header "__functional/is_transparent.h" }
module mem_fn { private header "__functional/mem_fn.h" }
module mem_fun_ref { private header "__functional/mem_fun_ref.h" }
module not_fn { private header "__functional/not_fn.h" }
module operations { private header "__functional/operations.h" }
module perfect_forward { private header "__functional/perfect_forward.h" }
module pointer_to_binary_function { private header "__functional/pointer_to_binary_function.h" }
module pointer_to_unary_function { private header "__functional/pointer_to_unary_function.h" }
module ranges_operations { private header "__functional/ranges_operations.h" }
module reference_wrapper { private header "__functional/reference_wrapper.h" }
module unary_function { private header "__functional/unary_function.h" }
module unary_negate { private header "__functional/unary_negate.h" }
module unwrap_ref { private header "__functional/unwrap_ref.h" }
module weak_result_type { private header "__functional/weak_result_type.h" }
}
}
module future {
header "future"
export *
}
module initializer_list {
header "initializer_list"
export *
}
module iomanip {
header "iomanip"
export *
}
module ios {
header "ios"
export iosfwd
export *
}
module iosfwd {
header "iosfwd"
export *
}
module iostream {
header "iostream"
export ios
export streambuf
export istream
export ostream
export *
}
module istream {
header "istream"
// FIXME: should re-export ios, streambuf?
export *
}
module iterator {
header "iterator"
export *
module __iterator {
module access { private header "__iterator/access.h" }
module advance { private header "__iterator/advance.h" }
module back_insert_iterator { private header "__iterator/back_insert_iterator.h" }
module common_iterator { private header "__iterator/common_iterator.h" }
module concepts { private header "__iterator/concepts.h" }
module counted_iterator { private header "__iterator/counted_iterator.h" }
module data { private header "__iterator/data.h" }
module default_sentinel { private header "__iterator/default_sentinel.h" }
module distance { private header "__iterator/distance.h" }
module empty { private header "__iterator/empty.h" }
module erase_if_container { private header "__iterator/erase_if_container.h" }
module front_insert_iterator { private header "__iterator/front_insert_iterator.h" }
module incrementable_traits { private header "__iterator/incrementable_traits.h" }
module indirectly_comparable { private header "__iterator/indirectly_comparable.h" }
module insert_iterator { private header "__iterator/insert_iterator.h" }
module istream_iterator { private header "__iterator/istream_iterator.h" }
module istreambuf_iterator { private header "__iterator/istreambuf_iterator.h" }
module iter_move { private header "__iterator/iter_move.h" }
module iter_swap { private header "__iterator/iter_swap.h" }
module iterator { private header "__iterator/iterator.h" }
module iterator_traits { private header "__iterator/iterator_traits.h" }
module move_iterator { private header "__iterator/move_iterator.h" }
module next { private header "__iterator/next.h" }
module ostream_iterator { private header "__iterator/ostream_iterator.h" }
module ostreambuf_iterator { private header "__iterator/ostreambuf_iterator.h" }
module prev { private header "__iterator/prev.h" }
module projected { private header "__iterator/projected.h" }
module readable_traits { private header "__iterator/readable_traits.h" }
module reverse_access { private header "__iterator/reverse_access.h" }
module reverse_iterator { private header "__iterator/reverse_iterator.h" }
module size { private header "__iterator/size.h" }
module unreachable_sentinel { private header "__iterator/unreachable_sentinel.h" }
module wrap_iter { private header "__iterator/wrap_iter.h" }
}
}
module latch {
requires cplusplus14
header "latch"
export *
}
module limits {
header "limits"
export *
}
module list {
header "list"
export initializer_list
export *
}
module locale {
header "locale"
export *
}
module map {
header "map"
export initializer_list
export *
}
module memory {
header "memory"
export *
module __memory {
module addressof { private header "__memory/addressof.h" }
module allocation_guard { private header "__memory/allocation_guard.h" }
module allocator { private header "__memory/allocator.h" }
module allocator_arg_t { private header "__memory/allocator_arg_t.h" }
module allocator_traits { private header "__memory/allocator_traits.h" }
module auto_ptr { private header "__memory/auto_ptr.h" }
module compressed_pair { private header "__memory/compressed_pair.h" }
module concepts { private header "__memory/concepts.h" }
module construct_at { private header "__memory/construct_at.h" }
module pointer_traits { private header "__memory/pointer_traits.h" }
module ranges_construct_at { private header "__memory/ranges_construct_at.h" }
module ranges_uninitialized_algorithms { private header "__memory/ranges_uninitialized_algorithms.h" }
module raw_storage_iterator { private header "__memory/raw_storage_iterator.h" }
module shared_ptr { private header "__memory/shared_ptr.h" }
module temporary_buffer { private header "__memory/temporary_buffer.h" }
module uninitialized_algorithms { private header "__memory/uninitialized_algorithms.h" }
module unique_ptr { private header "__memory/unique_ptr.h" }
module uses_allocator { private header "__memory/uses_allocator.h" }
module voidify { private header "__memory/voidify.h" }
}
}
module mutex {
header "mutex"
export *
}
module new {
header "new"
export *
}
module numbers {
header "numbers"
export *
}
module numeric {
header "numeric"
export *
module __numeric {
module accumulate { private header "__numeric/accumulate.h" }
module adjacent_difference { private header "__numeric/adjacent_difference.h" }
module exclusive_scan { private header "__numeric/exclusive_scan.h" }
module gcd_lcm { private header "__numeric/gcd_lcm.h" }
module inclusive_scan { private header "__numeric/inclusive_scan.h" }
module inner_product { private header "__numeric/inner_product.h" }
module iota { private header "__numeric/iota.h" }
module midpoint { private header "__numeric/midpoint.h" }
module partial_sum { private header "__numeric/partial_sum.h" }
module reduce { private header "__numeric/reduce.h" }
module transform_exclusive_scan { private header "__numeric/transform_exclusive_scan.h" }
module transform_inclusive_scan { private header "__numeric/transform_inclusive_scan.h" }
module transform_reduce { private header "__numeric/transform_reduce.h" }
}
}
module optional {
header "optional"
export *
}
module ostream {
header "ostream"
// FIXME: should re-export ios, streambuf?
export *
}
module queue {
header "queue"
export initializer_list
export *
}
module random {
header "random"
export initializer_list
export *
module __random {
module bernoulli_distribution { private header "__random/bernoulli_distribution.h" }
module binomial_distribution { private header "__random/binomial_distribution.h" }
module cauchy_distribution { private header "__random/cauchy_distribution.h" }
module chi_squared_distribution { private header "__random/chi_squared_distribution.h" }
module clamp_to_integral { private header "__random/clamp_to_integral.h" }
module default_random_engine { private header "__random/default_random_engine.h" }
module discard_block_engine { private header "__random/discard_block_engine.h" }
module discrete_distribution { private header "__random/discrete_distribution.h" }
module exponential_distribution { private header "__random/exponential_distribution.h" }
module extreme_value_distribution { private header "__random/extreme_value_distribution.h" }
module fisher_f_distribution { private header "__random/fisher_f_distribution.h" }
module gamma_distribution { private header "__random/gamma_distribution.h" }
module generate_canonical { private header "__random/generate_canonical.h" }
module geometric_distribution { private header "__random/geometric_distribution.h" }
module independent_bits_engine { private header "__random/independent_bits_engine.h" }
module is_seed_sequence { private header "__random/is_seed_sequence.h" }
module knuth_b { private header "__random/knuth_b.h" }
module linear_congruential_engine { private header "__random/linear_congruential_engine.h" }
module log2 { private header "__random/log2.h" }
module lognormal_distribution { private header "__random/lognormal_distribution.h" }
module mersenne_twister_engine { private header "__random/mersenne_twister_engine.h" }
module negative_binomial_distribution { private header "__random/negative_binomial_distribution.h" }
module normal_distribution { private header "__random/normal_distribution.h" }
module piecewise_constant_distribution { private header "__random/piecewise_constant_distribution.h" }
module piecewise_linear_distribution { private header "__random/piecewise_linear_distribution.h" }
module poisson_distribution { private header "__random/poisson_distribution.h" }
module random_device { private header "__random/random_device.h" }
module ranlux { private header "__random/ranlux.h" }
module seed_seq { private header "__random/seed_seq.h" }
module shuffle_order_engine { private header "__random/shuffle_order_engine.h" }
module student_t_distribution { private header "__random/student_t_distribution.h" }
module subtract_with_carry_engine { private header "__random/subtract_with_carry_engine.h" }
module uniform_int_distribution { private header "__random/uniform_int_distribution.h" }
module uniform_random_bit_generator { private header "__random/uniform_random_bit_generator.h" }
module uniform_real_distribution { private header "__random/uniform_real_distribution.h" }
module weibull_distribution { private header "__random/weibull_distribution.h" }
}
}
module ranges {
header "ranges"
export compare
export initializer_list
export iterator
export *
module __ranges {
module access { private header "__ranges/access.h" }
module all {
private header "__ranges/all.h"
export functional.__functional.compose
export functional.__functional.perfect_forward
}
module common_view { private header "__ranges/common_view.h" }
module concepts { private header "__ranges/concepts.h" }
module copyable_box { private header "__ranges/copyable_box.h" }
module counted {
private header "__ranges/counted.h"
export span
}
module dangling { private header "__ranges/dangling.h" }
module data { private header "__ranges/data.h" }
module drop_view { private header "__ranges/drop_view.h" }
module empty { private header "__ranges/empty.h" }
module empty_view { private header "__ranges/empty_view.h" }
module enable_borrowed_range { private header "__ranges/enable_borrowed_range.h" }
module enable_view { private header "__ranges/enable_view.h" }
module iota_view { private header "__ranges/iota_view.h" }
module join_view { private header "__ranges/join_view.h" }
module non_propagating_cache { private header "__ranges/non_propagating_cache.h" }
module owning_view { private header "__ranges/owning_view.h" }
module range_adaptor { private header "__ranges/range_adaptor.h" }
module ref_view { private header "__ranges/ref_view.h" }
module reverse_view { private header "__ranges/reverse_view.h" }
module single_view { private header "__ranges/single_view.h" }
module size { private header "__ranges/size.h" }
module subrange { private header "__ranges/subrange.h" }
module take_view { private header "__ranges/take_view.h" }
module transform_view {
private header "__ranges/transform_view.h"
export functional.__functional.bind_back
export functional.__functional.perfect_forward
}
module view_interface { private header "__ranges/view_interface.h" }
}
}
module ratio {
header "ratio"
export *
}
module regex {
header "regex"
export initializer_list
export *
}
module scoped_allocator {
header "scoped_allocator"
export *
}
module semaphore {
requires cplusplus14
header "semaphore"
export *
}
module set {
header "set"
export initializer_list
export *
}
module shared_mutex {
header "shared_mutex"
export version
}
module span {
header "span"
export ranges.__ranges.enable_borrowed_range
export version
}
module sstream {
header "sstream"
// FIXME: should re-export istream, ostream, ios, streambuf, string?
export *
}
module stack {
header "stack"
export initializer_list
export *
}
module stdexcept {
header "stdexcept"
export *
}
module streambuf {
header "streambuf"
export *
}
module string {
header "string"
export initializer_list
export string_view
export __string
export *
}
module string_view {
header "string_view"
export initializer_list
export __string
export *
}
module strstream {
header "strstream"
export *
}
module system_error {
header "system_error"
export *
}
module thread {
header "thread"
export *
module __thread {
module poll_with_backoff { private header "__thread/poll_with_backoff.h" }
module timed_backoff_policy { private header "__thread/timed_backoff_policy.h" }
}
}
module tuple {
header "tuple"
export *
}
module type_traits {
header "type_traits"
export functional.__functional.unwrap_ref
export *
}
module typeindex {
header "typeindex"
export *
}
module typeinfo {
header "typeinfo"
export *
}
module unordered_map {
header "unordered_map"
export initializer_list
export *
}
module unordered_set {
header "unordered_set"
export initializer_list
export *
}
module utility {
header "utility"
export initializer_list
export *
module __utility {
module as_const { private header "__utility/as_const.h" }
module auto_cast { private header "__utility/auto_cast.h" }
module cmp { private header "__utility/cmp.h" }
module declval { private header "__utility/declval.h" }
module exchange { private header "__utility/exchange.h" }
module forward { private header "__utility/forward.h" }
module in_place { private header "__utility/in_place.h" }
module integer_sequence { private header "__utility/integer_sequence.h" }
module move { private header "__utility/move.h" }
module pair { private header "__utility/pair.h" }
module piecewise_construct { private header "__utility/piecewise_construct.h" }
module priority_tag { private header "__utility/priority_tag.h" }
module rel_ops { private header "__utility/rel_ops.h" }
module swap { private header "__utility/swap.h" }
module to_underlying { private header "__utility/to_underlying.h" }
module transaction { private header "__utility/transaction.h" }
}
}
module valarray {
header "valarray"
export initializer_list
export *
}
module variant {
header "variant"
export *
module __variant {
module monostate { private header "__variant/monostate.h" }
}
}
module vector {
header "vector"
export initializer_list
export *
}
module version {
header "version"
export *
}
// __config not modularised due to a bug in Clang
// FIXME: These should be private.
module __availability { private header "__availability" export * }
module __bit_reference { private header "__bit_reference" export * }
module __bits { private header "__bits" export * }
module __debug { header "__debug" export * }
module __errc { private header "__errc" export * }
module __hash_table { header "__hash_table" export * }
module __locale { private header "__locale" export * }
module __mbstate_t { private header "__mbstate_t.h" export * }
module __mutex_base { private header "__mutex_base" export * }
module __node_handle { private header "__node_handle" export * }
module __nullptr { header "__nullptr" export * }
module __split_buffer { private header "__split_buffer" export * }
module __std_stream { private header "__std_stream" export * }
module __string { private header "__string" export * }
module __threading_support { header "__threading_support" export * }
module __tree { header "__tree" export * }
module __tuple { private header "__tuple" export * }
module __undef_macros { header "__undef_macros" export * }
module experimental {
requires cplusplus11
module algorithm {
header "experimental/algorithm"
export *
}
module coroutine {
requires coroutines
header "experimental/coroutine"
export *
}
module deque {
header "experimental/deque"
export *
}
module filesystem {
header "experimental/filesystem"
export *
}
module forward_list {
header "experimental/forward_list"
export *
}
module functional {
header "experimental/functional"
export *
}
module iterator {
header "experimental/iterator"
export *
}
module list {
header "experimental/list"
export *
}
module map {
header "experimental/map"
export *
}
module memory_resource {
header "experimental/memory_resource"
export *
}
module propagate_const {
header "experimental/propagate_const"
export *
}
module regex {
header "experimental/regex"
export *
}
module simd {
header "experimental/simd"
export *
}
module set {
header "experimental/set"
export *
}
module span {
header "span"
export *
}
module string {
header "experimental/string"
export *
}
module type_traits {
header "experimental/type_traits"
export *
}
module unordered_map {
header "experimental/unordered_map"
export *
}
module unordered_set {
header "experimental/unordered_set"
export *
}
module utility {
header "experimental/utility"
export *
}
module vector {
header "experimental/vector"
export *
}
// FIXME these should be private
module __memory {
header "experimental/__memory"
export *
}
} // end experimental
}
diff --git a/contrib/llvm-project/libcxx/include/numbers b/contrib/llvm-project/libcxx/include/numbers
index 2ac36695b888..35f5b04d9e41 100644
--- a/contrib/llvm-project/libcxx/include/numbers
+++ b/contrib/llvm-project/libcxx/include/numbers
@@ -1,133 +1,133 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_NUMBERS
#define _LIBCPP_NUMBERS
/*
numbers synopsis
namespace std::numbers {
template<class T> inline constexpr T e_v = unspecified;
template<class T> inline constexpr T log2e_v = unspecified;
template<class T> inline constexpr T log10e_v = unspecified;
template<class T> inline constexpr T pi_v = unspecified;
template<class T> inline constexpr T inv_pi_v = unspecified;
template<class T> inline constexpr T inv_sqrtpi_v = unspecified;
template<class T> inline constexpr T ln2_v = unspecified;
template<class T> inline constexpr T ln10_v = unspecified;
template<class T> inline constexpr T sqrt2_v = unspecified;
template<class T> inline constexpr T sqrt3_v = unspecified;
template<class T> inline constexpr T inv_sqrt3_v = unspecified;
template<class T> inline constexpr T egamma_v = unspecified;
template<class T> inline constexpr T phi_v = unspecified;
template<floating_point T> inline constexpr T e_v<T> = see below;
template<floating_point T> inline constexpr T log2e_v<T> = see below;
template<floating_point T> inline constexpr T log10e_v<T> = see below;
template<floating_point T> inline constexpr T pi_v<T> = see below;
template<floating_point T> inline constexpr T inv_pi_v<T> = see below;
template<floating_point T> inline constexpr T inv_sqrtpi_v<T> = see below;
template<floating_point T> inline constexpr T ln2_v<T> = see below;
template<floating_point T> inline constexpr T ln10_v<T> = see below;
template<floating_point T> inline constexpr T sqrt2_v<T> = see below;
template<floating_point T> inline constexpr T sqrt3_v<T> = see below;
template<floating_point T> inline constexpr T inv_sqrt3_v<T> = see below;
template<floating_point T> inline constexpr T egamma_v<T> = see below;
template<floating_point T> inline constexpr T phi_v<T> = see below;
inline constexpr double e = e_v<double>;
inline constexpr double log2e = log2e_v<double>;
inline constexpr double log10e = log10e_v<double>;
inline constexpr double pi = pi_v<double>;
inline constexpr double inv_pi = inv_pi_v<double>;
inline constexpr double inv_sqrtpi = inv_sqrtpi_v<double>;
inline constexpr double ln2 = ln2_v<double>;
inline constexpr double ln10 = ln10_v<double>;
inline constexpr double sqrt2 = sqrt2_v<double>;
inline constexpr double sqrt3 = sqrt3_v<double>;
inline constexpr double inv_sqrt3 = inv_sqrt3_v<double>;
inline constexpr double egamma = egamma_v<double>;
inline constexpr double phi = phi_v<double>;
}
*/
#include <__config>
#include <concepts>
#include <type_traits>
#include <version>
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
namespace numbers {
template <class _Tp>
inline constexpr bool __false = false;
template <class _Tp>
struct __illformed
{
static_assert(__false<_Tp>, "A program that instantiates a primary template of a mathematical constant variable template is ill-formed.");
};
template <class _Tp> inline constexpr _Tp e_v = __illformed<_Tp>{};
template <class _Tp> inline constexpr _Tp log2e_v = __illformed<_Tp>{};
template <class _Tp> inline constexpr _Tp log10e_v = __illformed<_Tp>{};
template <class _Tp> inline constexpr _Tp pi_v = __illformed<_Tp>{};
template <class _Tp> inline constexpr _Tp inv_pi_v = __illformed<_Tp>{};
template <class _Tp> inline constexpr _Tp inv_sqrtpi_v = __illformed<_Tp>{};
template <class _Tp> inline constexpr _Tp ln2_v = __illformed<_Tp>{};
template <class _Tp> inline constexpr _Tp ln10_v = __illformed<_Tp>{};
template <class _Tp> inline constexpr _Tp sqrt2_v = __illformed<_Tp>{};
template <class _Tp> inline constexpr _Tp sqrt3_v = __illformed<_Tp>{};
template <class _Tp> inline constexpr _Tp inv_sqrt3_v = __illformed<_Tp>{};
template <class _Tp> inline constexpr _Tp egamma_v = __illformed<_Tp>{};
template <class _Tp> inline constexpr _Tp phi_v = __illformed<_Tp>{};
template <floating_point _Tp> inline constexpr _Tp e_v<_Tp> = 2.718281828459045235360287471352662;
template <floating_point _Tp> inline constexpr _Tp log2e_v<_Tp> = 1.442695040888963407359924681001892;
template <floating_point _Tp> inline constexpr _Tp log10e_v<_Tp> = 0.434294481903251827651128918916605;
template <floating_point _Tp> inline constexpr _Tp pi_v<_Tp> = 3.141592653589793238462643383279502;
template <floating_point _Tp> inline constexpr _Tp inv_pi_v<_Tp> = 0.318309886183790671537767526745028;
template <floating_point _Tp> inline constexpr _Tp inv_sqrtpi_v<_Tp> = 0.564189583547756286948079451560772;
template <floating_point _Tp> inline constexpr _Tp ln2_v<_Tp> = 0.693147180559945309417232121458176;
template <floating_point _Tp> inline constexpr _Tp ln10_v<_Tp> = 2.302585092994045684017991454684364;
template <floating_point _Tp> inline constexpr _Tp sqrt2_v<_Tp> = 1.414213562373095048801688724209698;
template <floating_point _Tp> inline constexpr _Tp sqrt3_v<_Tp> = 1.732050807568877293527446341505872;
template <floating_point _Tp> inline constexpr _Tp inv_sqrt3_v<_Tp> = 0.577350269189625764509148780501957;
template <floating_point _Tp> inline constexpr _Tp egamma_v<_Tp> = 0.577215664901532860606512090082402;
template <floating_point _Tp> inline constexpr _Tp phi_v<_Tp> = 1.618033988749894848204586834365638;
inline constexpr double e = e_v<double>;
inline constexpr double log2e = log2e_v<double>;
inline constexpr double log10e = log10e_v<double>;
inline constexpr double pi = pi_v<double>;
inline constexpr double inv_pi = inv_pi_v<double>;
inline constexpr double inv_sqrtpi = inv_sqrtpi_v<double>;
inline constexpr double ln2 = ln2_v<double>;
inline constexpr double ln10 = ln10_v<double>;
inline constexpr double sqrt2 = sqrt2_v<double>;
inline constexpr double sqrt3 = sqrt3_v<double>;
inline constexpr double inv_sqrt3 = inv_sqrt3_v<double>;
inline constexpr double egamma = egamma_v<double>;
inline constexpr double phi = phi_v<double>;
} // namespace numbers
_LIBCPP_END_NAMESPACE_STD
-#endif //_LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif //!defined(_LIBCPP_HAS_NO_CONCEPTS)
#endif // _LIBCPP_NUMBERS
diff --git a/contrib/llvm-project/libcxx/include/ranges b/contrib/llvm-project/libcxx/include/ranges
index f7c543d7316c..2d79d87eef89 100644
--- a/contrib/llvm-project/libcxx/include/ranges
+++ b/contrib/llvm-project/libcxx/include/ranges
@@ -1,252 +1,252 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_RANGES
#define _LIBCPP_RANGES
/*
#include <compare> // see [compare.syn]
#include <initializer_list> // see [initializer.list.syn]
#include <iterator> // see [iterator.synopsis]
namespace std::ranges {
inline namespace unspecified {
// [range.access], range access
inline constexpr unspecified begin = unspecified;
inline constexpr unspecified end = unspecified;
inline constexpr unspecified cbegin = unspecified;
inline constexpr unspecified cend = unspecified;
inline constexpr unspecified size = unspecified;
inline constexpr unspecified ssize = unspecified;
}
// [range.range], ranges
template<class T>
concept range = see below;
template<class T>
inline constexpr bool enable_borrowed_range = false;
template<class T>
using iterator_t = decltype(ranges::begin(declval<T&>()));
template<range R>
using sentinel_t = decltype(ranges::end(declval<R&>()));
template<range R>
using range_difference_t = iter_difference_t<iterator_t<R>>;
template<sized_range R>
using range_size_t = decltype(ranges::size(declval<R&>()));
template<range R>
using range_value_t = iter_value_t<iterator_t<R>>;
template<range R>
using range_reference_t = iter_reference_t<iterator_t<R>>;
template<range R>
using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>;
// [range.sized], sized ranges
template<class>
inline constexpr bool disable_sized_range = false;
template<class T>
concept sized_range = ...;
// [range.view], views
template<class T>
inline constexpr bool enable_view = ...;
struct view_base { };
template<class T>
concept view = ...;
// [range.refinements], other range refinements
template<class R, class T>
concept output_range = see below;
template<class T>
concept input_range = see below;
template<class T>
concept forward_range = see below;
template<class T>
concept bidirectional_range = see below;
template<class T>
concept random_access_range = see below;
template<class T>
concept contiguous_range = see below;
template <class _Tp>
concept common_range = see below;
template<class T>
concept viewable_range = see below;
// [view.interface], class template view_interface
template<class D>
requires is_class_v<D> && same_as<D, remove_cv_t<D>>
class view_interface;
// [range.subrange], sub-ranges
enum class subrange_kind : bool { unsized, sized };
template<input_or_output_iterator I, sentinel_for<I> S = I, subrange_kind K = see below>
requires (K == subrange_kind::sized || !sized_sentinel_for<S, I>)
class subrange;
template<class I, class S, subrange_kind K>
inline constexpr bool enable_borrowed_range<subrange<I, S, K>> = true;
// [range.dangling], dangling iterator handling
struct dangling;
template<range R>
using borrowed_iterator_t = see below;
template<range R>
using borrowed_subrange_t = see below;
// [range.empty], empty view
template<class T>
requires is_object_v<T>
class empty_view;
// [range.all], all view
namespace views {
inline constexpr unspecified all = unspecified;
template<viewable_range R>
using all_t = decltype(all(declval<R>()));
}
template<range R>
requires is_object_v<R>
class ref_view;
template<class T>
inline constexpr bool enable_borrowed_range<ref_view<T>> = true;
template<range R>
requires see below
class owning_view;
template<class T>
inline constexpr bool enable_borrowed_range<owning_view<T>> = enable_borrowed_range<T>;
// [range.drop], drop view
template<view V>
class drop_view;
template<class T>
inline constexpr bool enable_borrowed_range<drop_view<T>> = enable_borrowed_range<T>;
// [range.transform], transform view
template<input_range V, copy_constructible F>
requires view<V> && is_object_v<F> &&
regular_invocable<F&, range_reference_t<V>> &&
can-reference<invoke_result_t<F&, range_reference_t<V>>>
class transform_view;
// [range.counted], counted view
namespace views { inline constexpr unspecified counted = unspecified; }
// [range.common], common view
template<view V>
requires (!common_range<V> && copyable<iterator_t<V>>)
class common_view;
// [range.reverse], reverse view
template<view V>
requires bidirectional_range<V>
class reverse_view;
template<class T>
inline constexpr bool enable_borrowed_range<reverse_view<T>> = enable_borrowed_range<T>;
template<class T>
inline constexpr bool enable_borrowed_range<common_view<T>> = enable_borrowed_range<T>;
// [range.take], take view
template<view> class take_view;
template<class T>
inline constexpr bool enable_borrowed_range<take_view<T>> = enable_borrowed_range<T>;
template<copy_constructible T>
requires is_object_v<T>
class single_view;
template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>
requires weakly-equality-comparable-with<W, Bound> && copyable<W>
class iota_view;
template<class W, class Bound>
inline constexpr bool enable_borrowed_range<iota_view<W, Bound>> = true;
// [range.join], join view
template<input_range V>
requires view<V> && input_range<range_reference_t<V>>
class join_view;
}
*/
// Make sure all feature-test macros are available.
#include <version>
// Enable the contents of the header only when libc++ was built with LIBCXX_ENABLE_INCOMPLETE_FEATURES.
#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
#include <__config>
#include <__ranges/access.h>
#include <__ranges/all.h>
#include <__ranges/common_view.h>
#include <__ranges/concepts.h>
#include <__ranges/counted.h>
#include <__ranges/dangling.h>
#include <__ranges/data.h>
#include <__ranges/drop_view.h>
#include <__ranges/empty.h>
#include <__ranges/empty_view.h>
#include <__ranges/enable_borrowed_range.h>
#include <__ranges/enable_view.h>
#include <__ranges/iota_view.h>
#include <__ranges/join_view.h>
#include <__ranges/ref_view.h>
#include <__ranges/reverse_view.h>
#include <__ranges/single_view.h>
#include <__ranges/size.h>
#include <__ranges/subrange.h>
#include <__ranges/take_view.h>
#include <__ranges/transform_view.h>
#include <__ranges/view_interface.h>
#include <compare> // Required by the standard.
#include <initializer_list> // Required by the standard.
#include <iterator> // Required by the standard.
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
namespace views = ranges::views;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD
#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
#endif // _LIBCPP_RANGES
diff --git a/contrib/llvm-project/libcxx/include/string b/contrib/llvm-project/libcxx/include/string
index 3616de8a214d..01cff902e07d 100644
--- a/contrib/llvm-project/libcxx/include/string
+++ b/contrib/llvm-project/libcxx/include/string
@@ -1,4524 +1,4509 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_STRING
#define _LIBCPP_STRING
/*
string synopsis
namespace std
{
template <class stateT>
class fpos
{
private:
stateT st;
public:
fpos(streamoff = streamoff());
operator streamoff() const;
stateT state() const;
void state(stateT);
fpos& operator+=(streamoff);
fpos operator+ (streamoff) const;
fpos& operator-=(streamoff);
fpos operator- (streamoff) const;
};
template <class stateT> streamoff operator-(const fpos<stateT>& x, const fpos<stateT>& y);
template <class stateT> bool operator==(const fpos<stateT>& x, const fpos<stateT>& y);
template <class stateT> bool operator!=(const fpos<stateT>& x, const fpos<stateT>& y);
template <class charT>
struct char_traits
{
typedef charT char_type;
typedef ... int_type;
typedef streamoff off_type;
typedef streampos pos_type;
typedef mbstate_t state_type;
static void assign(char_type& c1, const char_type& c2) noexcept;
static constexpr bool eq(char_type c1, char_type c2) noexcept;
static constexpr bool lt(char_type c1, char_type c2) noexcept;
static int compare(const char_type* s1, const char_type* s2, size_t n);
static size_t length(const char_type* s);
static const char_type* find(const char_type* s, size_t n, const char_type& a);
static char_type* move(char_type* s1, const char_type* s2, size_t n);
static char_type* copy(char_type* s1, const char_type* s2, size_t n);
static char_type* assign(char_type* s, size_t n, char_type a);
static constexpr int_type not_eof(int_type c) noexcept;
static constexpr char_type to_char_type(int_type c) noexcept;
static constexpr int_type to_int_type(char_type c) noexcept;
static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept;
static constexpr int_type eof() noexcept;
};
template <> struct char_traits<char>;
template <> struct char_traits<wchar_t>;
template <> struct char_traits<char8_t>; // C++20
template <> struct char_traits<char16_t>;
template <> struct char_traits<char32_t>;
template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
class basic_string
{
public:
// types:
typedef traits traits_type;
typedef typename traits_type::char_type value_type;
typedef Allocator allocator_type;
typedef typename allocator_type::size_type size_type;
typedef typename allocator_type::difference_type difference_type;
typedef typename allocator_type::reference reference;
typedef typename allocator_type::const_reference const_reference;
typedef typename allocator_type::pointer pointer;
typedef typename allocator_type::const_pointer const_pointer;
typedef implementation-defined iterator;
typedef implementation-defined const_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
static const size_type npos = -1;
basic_string()
noexcept(is_nothrow_default_constructible<allocator_type>::value);
explicit basic_string(const allocator_type& a);
basic_string(const basic_string& str);
basic_string(basic_string&& str)
noexcept(is_nothrow_move_constructible<allocator_type>::value);
basic_string(const basic_string& str, size_type pos,
const allocator_type& a = allocator_type());
basic_string(const basic_string& str, size_type pos, size_type n,
const Allocator& a = Allocator());
template<class T>
basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator()); // C++17
template <class T>
explicit basic_string(const T& t, const Allocator& a = Allocator()); // C++17
basic_string(const value_type* s, const allocator_type& a = allocator_type());
basic_string(const value_type* s, size_type n, const allocator_type& a = allocator_type());
basic_string(nullptr_t) = delete; // C++2b
basic_string(size_type n, value_type c, const allocator_type& a = allocator_type());
template<class InputIterator>
basic_string(InputIterator begin, InputIterator end,
const allocator_type& a = allocator_type());
basic_string(initializer_list<value_type>, const Allocator& = Allocator());
basic_string(const basic_string&, const Allocator&);
basic_string(basic_string&&, const Allocator&);
~basic_string();
operator basic_string_view<charT, traits>() const noexcept;
basic_string& operator=(const basic_string& str);
template <class T>
basic_string& operator=(const T& t); // C++17
basic_string& operator=(basic_string&& str)
noexcept(
allocator_type::propagate_on_container_move_assignment::value ||
allocator_type::is_always_equal::value ); // C++17
basic_string& operator=(const value_type* s);
basic_string& operator=(nullptr_t) = delete; // C++2b
basic_string& operator=(value_type c);
basic_string& operator=(initializer_list<value_type>);
iterator begin() noexcept;
const_iterator begin() const noexcept;
iterator end() noexcept;
const_iterator end() const noexcept;
reverse_iterator rbegin() noexcept;
const_reverse_iterator rbegin() const noexcept;
reverse_iterator rend() noexcept;
const_reverse_iterator rend() const noexcept;
const_iterator cbegin() const noexcept;
const_iterator cend() const noexcept;
const_reverse_iterator crbegin() const noexcept;
const_reverse_iterator crend() const noexcept;
size_type size() const noexcept;
size_type length() const noexcept;
size_type max_size() const noexcept;
size_type capacity() const noexcept;
void resize(size_type n, value_type c);
void resize(size_type n);
template<class Operation>
constexpr void resize_and_overwrite(size_type n, Operation op); // since C++23
void reserve(size_type res_arg);
void reserve(); // deprecated in C++20
void shrink_to_fit();
void clear() noexcept;
bool empty() const noexcept;
const_reference operator[](size_type pos) const;
reference operator[](size_type pos);
const_reference at(size_type n) const;
reference at(size_type n);
basic_string& operator+=(const basic_string& str);
template <class T>
basic_string& operator+=(const T& t); // C++17
basic_string& operator+=(const value_type* s);
basic_string& operator+=(value_type c);
basic_string& operator+=(initializer_list<value_type>);
basic_string& append(const basic_string& str);
template <class T>
basic_string& append(const T& t); // C++17
basic_string& append(const basic_string& str, size_type pos, size_type n=npos); //C++14
template <class T>
basic_string& append(const T& t, size_type pos, size_type n=npos); // C++17
basic_string& append(const value_type* s, size_type n);
basic_string& append(const value_type* s);
basic_string& append(size_type n, value_type c);
template<class InputIterator>
basic_string& append(InputIterator first, InputIterator last);
basic_string& append(initializer_list<value_type>);
void push_back(value_type c);
void pop_back();
reference front();
const_reference front() const;
reference back();
const_reference back() const;
basic_string& assign(const basic_string& str);
template <class T>
basic_string& assign(const T& t); // C++17
basic_string& assign(basic_string&& str);
basic_string& assign(const basic_string& str, size_type pos, size_type n=npos); // C++14
template <class T>
basic_string& assign(const T& t, size_type pos, size_type n=npos); // C++17
basic_string& assign(const value_type* s, size_type n);
basic_string& assign(const value_type* s);
basic_string& assign(size_type n, value_type c);
template<class InputIterator>
basic_string& assign(InputIterator first, InputIterator last);
basic_string& assign(initializer_list<value_type>);
basic_string& insert(size_type pos1, const basic_string& str);
template <class T>
basic_string& insert(size_type pos1, const T& t);
basic_string& insert(size_type pos1, const basic_string& str,
size_type pos2, size_type n);
template <class T>
basic_string& insert(size_type pos1, const T& t, size_type pos2, size_type n); // C++17
basic_string& insert(size_type pos, const value_type* s, size_type n=npos); //C++14
basic_string& insert(size_type pos, const value_type* s);
basic_string& insert(size_type pos, size_type n, value_type c);
iterator insert(const_iterator p, value_type c);
iterator insert(const_iterator p, size_type n, value_type c);
template<class InputIterator>
iterator insert(const_iterator p, InputIterator first, InputIterator last);
iterator insert(const_iterator p, initializer_list<value_type>);
basic_string& erase(size_type pos = 0, size_type n = npos);
iterator erase(const_iterator position);
iterator erase(const_iterator first, const_iterator last);
basic_string& replace(size_type pos1, size_type n1, const basic_string& str);
template <class T>
basic_string& replace(size_type pos1, size_type n1, const T& t); // C++17
basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
size_type pos2, size_type n2=npos); // C++14
template <class T>
basic_string& replace(size_type pos1, size_type n1, const T& t,
size_type pos2, size_type n); // C++17
basic_string& replace(size_type pos, size_type n1, const value_type* s, size_type n2);
basic_string& replace(size_type pos, size_type n1, const value_type* s);
basic_string& replace(size_type pos, size_type n1, size_type n2, value_type c);
basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
template <class T>
basic_string& replace(const_iterator i1, const_iterator i2, const T& t); // C++17
basic_string& replace(const_iterator i1, const_iterator i2, const value_type* s, size_type n);
basic_string& replace(const_iterator i1, const_iterator i2, const value_type* s);
basic_string& replace(const_iterator i1, const_iterator i2, size_type n, value_type c);
template<class InputIterator>
basic_string& replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2);
basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<value_type>);
size_type copy(value_type* s, size_type n, size_type pos = 0) const;
basic_string substr(size_type pos = 0, size_type n = npos) const;
void swap(basic_string& str)
noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value ||
allocator_traits<allocator_type>::is_always_equal::value); // C++17
const value_type* c_str() const noexcept;
const value_type* data() const noexcept;
value_type* data() noexcept; // C++17
allocator_type get_allocator() const noexcept;
size_type find(const basic_string& str, size_type pos = 0) const noexcept;
template <class T>
size_type find(const T& t, size_type pos = 0) const noexcept; // C++17, noexcept as an extension
size_type find(const value_type* s, size_type pos, size_type n) const noexcept;
size_type find(const value_type* s, size_type pos = 0) const noexcept;
size_type find(value_type c, size_type pos = 0) const noexcept;
size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
template <class T>
size_type rfind(const T& t, size_type pos = npos) const noexcept; // C++17, noexcept as an extension
size_type rfind(const value_type* s, size_type pos, size_type n) const noexcept;
size_type rfind(const value_type* s, size_type pos = npos) const noexcept;
size_type rfind(value_type c, size_type pos = npos) const noexcept;
size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept;
template <class T>
size_type find_first_of(const T& t, size_type pos = 0) const noexcept; // C++17, noexcept as an extension
size_type find_first_of(const value_type* s, size_type pos, size_type n) const noexcept;
size_type find_first_of(const value_type* s, size_type pos = 0) const noexcept;
size_type find_first_of(value_type c, size_type pos = 0) const noexcept;
size_type find_last_of(const basic_string& str, size_type pos = npos) const noexcept;
template <class T>
size_type find_last_of(const T& t, size_type pos = npos) const noexcept noexcept; // C++17, noexcept as an extension
size_type find_last_of(const value_type* s, size_type pos, size_type n) const noexcept;
size_type find_last_of(const value_type* s, size_type pos = npos) const noexcept;
size_type find_last_of(value_type c, size_type pos = npos) const noexcept;
size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept;
template <class T>
size_type find_first_not_of(const T& t, size_type pos = 0) const noexcept; // C++17, noexcept as an extension
size_type find_first_not_of(const value_type* s, size_type pos, size_type n) const noexcept;
size_type find_first_not_of(const value_type* s, size_type pos = 0) const noexcept;
size_type find_first_not_of(value_type c, size_type pos = 0) const noexcept;
size_type find_last_not_of(const basic_string& str, size_type pos = npos) const noexcept;
template <class T>
size_type find_last_not_of(const T& t, size_type pos = npos) const noexcept; // C++17, noexcept as an extension
size_type find_last_not_of(const value_type* s, size_type pos, size_type n) const noexcept;
size_type find_last_not_of(const value_type* s, size_type pos = npos) const noexcept;
size_type find_last_not_of(value_type c, size_type pos = npos) const noexcept;
int compare(const basic_string& str) const noexcept;
template <class T>
int compare(const T& t) const noexcept; // C++17, noexcept as an extension
int compare(size_type pos1, size_type n1, const basic_string& str) const;
template <class T>
int compare(size_type pos1, size_type n1, const T& t) const; // C++17
int compare(size_type pos1, size_type n1, const basic_string& str,
size_type pos2, size_type n2=npos) const; // C++14
template <class T>
int compare(size_type pos1, size_type n1, const T& t,
size_type pos2, size_type n2=npos) const; // C++17
int compare(const value_type* s) const noexcept;
int compare(size_type pos1, size_type n1, const value_type* s) const;
int compare(size_type pos1, size_type n1, const value_type* s, size_type n2) const;
bool starts_with(basic_string_view<charT, traits> sv) const noexcept; // C++20
bool starts_with(charT c) const noexcept; // C++20
bool starts_with(const charT* s) const; // C++20
bool ends_with(basic_string_view<charT, traits> sv) const noexcept; // C++20
bool ends_with(charT c) const noexcept; // C++20
bool ends_with(const charT* s) const; // C++20
constexpr bool contains(basic_string_view<charT, traits> sv) const noexcept; // C++2b
constexpr bool contains(charT c) const noexcept; // C++2b
constexpr bool contains(const charT* s) const; // C++2b
bool __invariants() const;
};
template<class InputIterator,
class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
basic_string(InputIterator, InputIterator, Allocator = Allocator())
-> basic_string<typename iterator_traits<InputIterator>::value_type,
char_traits<typename iterator_traits<InputIterator>::value_type>,
Allocator>; // C++17
template<class charT, class traits, class Allocator>
basic_string<charT, traits, Allocator>
operator+(const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs);
template<class charT, class traits, class Allocator>
basic_string<charT, traits, Allocator>
operator+(const charT* lhs , const basic_string<charT,traits,Allocator>&rhs);
template<class charT, class traits, class Allocator>
basic_string<charT, traits, Allocator>
operator+(charT lhs, const basic_string<charT,traits,Allocator>& rhs);
template<class charT, class traits, class Allocator>
basic_string<charT, traits, Allocator>
operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
template<class charT, class traits, class Allocator>
basic_string<charT, traits, Allocator>
operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs);
template<class charT, class traits, class Allocator>
bool operator==(const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator==(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator==(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator!=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator!=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator< (const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator< (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator< (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator> (const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator> (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator> (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator<=(const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator<=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator<=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator>=(const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator>=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator>=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
void swap(basic_string<charT, traits, Allocator>& lhs,
basic_string<charT, traits, Allocator>& rhs)
noexcept(noexcept(lhs.swap(rhs)));
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);
template<class charT, class traits, class Allocator>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os, const basic_string<charT, traits, Allocator>& str);
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str,
charT delim);
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);
template<class charT, class traits, class Allocator, class U>
typename basic_string<charT, traits, Allocator>::size_type
erase(basic_string<charT, traits, Allocator>& c, const U& value); // C++20
template<class charT, class traits, class Allocator, class Predicate>
typename basic_string<charT, traits, Allocator>::size_type
erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred); // C++20
typedef basic_string<char> string;
typedef basic_string<wchar_t> wstring;
typedef basic_string<char8_t> u8string; // C++20
typedef basic_string<char16_t> u16string;
typedef basic_string<char32_t> u32string;
int stoi (const string& str, size_t* idx = nullptr, int base = 10);
long stol (const string& str, size_t* idx = nullptr, int base = 10);
unsigned long stoul (const string& str, size_t* idx = nullptr, int base = 10);
long long stoll (const string& str, size_t* idx = nullptr, int base = 10);
unsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10);
float stof (const string& str, size_t* idx = nullptr);
double stod (const string& str, size_t* idx = nullptr);
long double stold(const string& str, size_t* idx = nullptr);
string to_string(int val);
string to_string(unsigned val);
string to_string(long val);
string to_string(unsigned long val);
string to_string(long long val);
string to_string(unsigned long long val);
string to_string(float val);
string to_string(double val);
string to_string(long double val);
int stoi (const wstring& str, size_t* idx = nullptr, int base = 10);
long stol (const wstring& str, size_t* idx = nullptr, int base = 10);
unsigned long stoul (const wstring& str, size_t* idx = nullptr, int base = 10);
long long stoll (const wstring& str, size_t* idx = nullptr, int base = 10);
unsigned long long stoull(const wstring& str, size_t* idx = nullptr, int base = 10);
float stof (const wstring& str, size_t* idx = nullptr);
double stod (const wstring& str, size_t* idx = nullptr);
long double stold(const wstring& str, size_t* idx = nullptr);
wstring to_wstring(int val);
wstring to_wstring(unsigned val);
wstring to_wstring(long val);
wstring to_wstring(unsigned long val);
wstring to_wstring(long long val);
wstring to_wstring(unsigned long long val);
wstring to_wstring(float val);
wstring to_wstring(double val);
wstring to_wstring(long double val);
template <> struct hash<string>;
template <> struct hash<u8string>; // C++20
template <> struct hash<u16string>;
template <> struct hash<u32string>;
template <> struct hash<wstring>;
basic_string<char> operator "" s( const char *str, size_t len ); // C++14
basic_string<wchar_t> operator "" s( const wchar_t *str, size_t len ); // C++14
basic_string<char8_t> operator "" s( const char8_t *str, size_t len ); // C++20
basic_string<char16_t> operator "" s( const char16_t *str, size_t len ); // C++14
basic_string<char32_t> operator "" s( const char32_t *str, size_t len ); // C++14
} // std
*/
#include <__config>
#include <__debug>
#include <__functional_base>
#include <__iterator/wrap_iter.h>
#include <algorithm>
#include <compare>
#include <cstdio> // EOF
#include <cstdlib>
#include <cstring>
#include <initializer_list>
#include <iosfwd>
#include <iterator>
#include <memory>
#include <stdexcept>
#include <string_view>
#include <type_traits>
#include <utility>
#include <version>
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
# include <cwchar>
#endif
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
# include <cstdint>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_PUSH_MACROS
#include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD
// fpos
template <class _StateT>
class _LIBCPP_TEMPLATE_VIS fpos
{
private:
_StateT __st_;
streamoff __off_;
public:
_LIBCPP_INLINE_VISIBILITY fpos(streamoff __off = streamoff()) : __st_(), __off_(__off) {}
_LIBCPP_INLINE_VISIBILITY operator streamoff() const {return __off_;}
_LIBCPP_INLINE_VISIBILITY _StateT state() const {return __st_;}
_LIBCPP_INLINE_VISIBILITY void state(_StateT __st) {__st_ = __st;}
_LIBCPP_INLINE_VISIBILITY fpos& operator+=(streamoff __off) {__off_ += __off; return *this;}
_LIBCPP_INLINE_VISIBILITY fpos operator+ (streamoff __off) const {fpos __t(*this); __t += __off; return __t;}
_LIBCPP_INLINE_VISIBILITY fpos& operator-=(streamoff __off) {__off_ -= __off; return *this;}
_LIBCPP_INLINE_VISIBILITY fpos operator- (streamoff __off) const {fpos __t(*this); __t -= __off; return __t;}
};
template <class _StateT>
inline _LIBCPP_INLINE_VISIBILITY
streamoff operator-(const fpos<_StateT>& __x, const fpos<_StateT>& __y)
{return streamoff(__x) - streamoff(__y);}
template <class _StateT>
inline _LIBCPP_INLINE_VISIBILITY
bool operator==(const fpos<_StateT>& __x, const fpos<_StateT>& __y)
{return streamoff(__x) == streamoff(__y);}
template <class _StateT>
inline _LIBCPP_INLINE_VISIBILITY
bool operator!=(const fpos<_StateT>& __x, const fpos<_StateT>& __y)
{return streamoff(__x) != streamoff(__y);}
// basic_string
template<class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>& __x,
const basic_string<_CharT, _Traits, _Allocator>& __y);
template<class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>
operator+(const _CharT* __x, const basic_string<_CharT,_Traits,_Allocator>& __y);
template<class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>
operator+(_CharT __x, const basic_string<_CharT,_Traits,_Allocator>& __y);
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, const _CharT* __y);
template<class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, _CharT __y);
_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS string operator+<char, char_traits<char>, allocator<char> >(char const*, string const&))
-#ifndef _LIBCPP_ABI_NO_BASIC_STRING_BASE_CLASS
-template <bool>
-struct __basic_string_common;
-
-template <>
-struct __basic_string_common<true> {
- // Both are defined in string.cpp
- _LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void __throw_length_error() const;
- _LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void __throw_out_of_range() const;
-};
-#endif
-
template <class _Iter>
struct __string_is_trivial_iterator : public false_type {};
template <class _Tp>
struct __string_is_trivial_iterator<_Tp*>
: public is_arithmetic<_Tp> {};
template <class _Iter>
struct __string_is_trivial_iterator<__wrap_iter<_Iter> >
: public __string_is_trivial_iterator<_Iter> {};
template <class _CharT, class _Traits, class _Tp>
struct __can_be_converted_to_string_view : public _BoolConstant<
is_convertible<const _Tp&, basic_string_view<_CharT, _Traits> >::value &&
!is_convertible<const _Tp&, const _CharT*>::value
> {};
#ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
template <class _CharT, size_t = sizeof(_CharT)>
struct __padding
{
unsigned char __xx[sizeof(_CharT)-1];
};
template <class _CharT>
struct __padding<_CharT, 1>
{
};
#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
#ifndef _LIBCPP_HAS_NO_CHAR8_T
typedef basic_string<char8_t> u8string;
#endif
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
typedef basic_string<char16_t> u16string;
typedef basic_string<char32_t> u32string;
#endif
template<class _CharT, class _Traits, class _Allocator>
class
_LIBCPP_TEMPLATE_VIS
#ifndef _LIBCPP_HAS_NO_CHAR8_T
_LIBCPP_PREFERRED_NAME(u8string)
#endif
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
_LIBCPP_PREFERRED_NAME(u16string)
_LIBCPP_PREFERRED_NAME(u32string)
#endif
basic_string
-#ifndef _LIBCPP_ABI_NO_BASIC_STRING_BASE_CLASS
- : private __basic_string_common<true> // This base class is historical, but it needs to remain for ABI compatibility
-#endif
{
public:
typedef basic_string __self;
typedef basic_string_view<_CharT, _Traits> __self_view;
typedef _Traits traits_type;
typedef _CharT value_type;
typedef _Allocator allocator_type;
typedef allocator_traits<allocator_type> __alloc_traits;
typedef typename __alloc_traits::size_type size_type;
typedef typename __alloc_traits::difference_type difference_type;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef typename __alloc_traits::pointer pointer;
typedef typename __alloc_traits::const_pointer const_pointer;
static_assert((!is_array<value_type>::value), "Character type of basic_string must not be an array");
static_assert(( is_standard_layout<value_type>::value), "Character type of basic_string must be standard-layout");
static_assert(( is_trivial<value_type>::value), "Character type of basic_string must be trivial");
static_assert(( is_same<_CharT, typename traits_type::char_type>::value),
"traits_type::char_type must be the same type as CharT");
static_assert(( is_same<typename allocator_type::value_type, value_type>::value),
"Allocator::value_type must be same type as value_type");
typedef __wrap_iter<pointer> iterator;
typedef __wrap_iter<const_pointer> const_iterator;
typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
private:
#ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
struct __long
{
pointer __data_;
size_type __size_;
size_type __cap_;
};
#ifdef _LIBCPP_BIG_ENDIAN
static const size_type __short_mask = 0x01;
static const size_type __long_mask = 0x1ul;
#else // _LIBCPP_BIG_ENDIAN
static const size_type __short_mask = 0x80;
static const size_type __long_mask = ~(size_type(~0) >> 1);
#endif // _LIBCPP_BIG_ENDIAN
enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
(sizeof(__long) - 1)/sizeof(value_type) : 2};
struct __short
{
value_type __data_[__min_cap];
struct
: __padding<value_type>
{
unsigned char __size_;
};
};
#else
struct __long
{
size_type __cap_;
size_type __size_;
pointer __data_;
};
#ifdef _LIBCPP_BIG_ENDIAN
static const size_type __short_mask = 0x80;
static const size_type __long_mask = ~(size_type(~0) >> 1);
#else // _LIBCPP_BIG_ENDIAN
static const size_type __short_mask = 0x01;
static const size_type __long_mask = 0x1ul;
#endif // _LIBCPP_BIG_ENDIAN
enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
(sizeof(__long) - 1)/sizeof(value_type) : 2};
struct __short
{
union
{
unsigned char __size_;
value_type __lx;
};
value_type __data_[__min_cap];
};
#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
union __ulx{__long __lx; __short __lxx;};
enum {__n_words = sizeof(__ulx) / sizeof(size_type)};
struct __raw
{
size_type __words[__n_words];
};
struct __rep
{
union
{
__long __l;
__short __s;
__raw __r;
};
};
__compressed_pair<__rep, allocator_type> __r_;
public:
_LIBCPP_TEMPLATE_DATA_VIS
static const size_type npos = -1;
_LIBCPP_INLINE_VISIBILITY basic_string()
_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
_LIBCPP_INLINE_VISIBILITY explicit basic_string(const allocator_type& __a)
#if _LIBCPP_STD_VER <= 14
_NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value);
#else
_NOEXCEPT;
#endif
basic_string(const basic_string& __str);
basic_string(const basic_string& __str, const allocator_type& __a);
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
basic_string(basic_string&& __str)
#if _LIBCPP_STD_VER <= 14
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
#else
_NOEXCEPT;
#endif
_LIBCPP_INLINE_VISIBILITY
basic_string(basic_string&& __str, const allocator_type& __a);
#endif // _LIBCPP_CXX03_LANG
template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> >
_LIBCPP_INLINE_VISIBILITY
basic_string(const _CharT* __s) : __r_(__default_init_tag(), __default_init_tag()) {
_LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr");
__init(__s, traits_type::length(__s));
_VSTD::__debug_db_insert_c(this);
}
template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> >
_LIBCPP_INLINE_VISIBILITY
basic_string(const _CharT* __s, const _Allocator& __a);
#if _LIBCPP_STD_VER > 20
basic_string(nullptr_t) = delete;
#endif
_LIBCPP_INLINE_VISIBILITY
basic_string(const _CharT* __s, size_type __n);
_LIBCPP_INLINE_VISIBILITY
basic_string(const _CharT* __s, size_type __n, const _Allocator& __a);
_LIBCPP_INLINE_VISIBILITY
basic_string(size_type __n, _CharT __c);
template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> >
_LIBCPP_INLINE_VISIBILITY
basic_string(size_type __n, _CharT __c, const _Allocator& __a);
basic_string(const basic_string& __str, size_type __pos, size_type __n,
const _Allocator& __a = _Allocator());
_LIBCPP_INLINE_VISIBILITY
basic_string(const basic_string& __str, size_type __pos,
const _Allocator& __a = _Allocator());
template<class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> >
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
basic_string(const _Tp& __t, size_type __pos, size_type __n,
const allocator_type& __a = allocator_type());
template<class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
!__is_same_uncvref<_Tp, basic_string>::value> >
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
explicit basic_string(const _Tp& __t);
template<class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> >
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
explicit basic_string(const _Tp& __t, const allocator_type& __a);
template<class _InputIterator, class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value> >
_LIBCPP_INLINE_VISIBILITY
basic_string(_InputIterator __first, _InputIterator __last);
template<class _InputIterator, class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value> >
_LIBCPP_INLINE_VISIBILITY
basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a);
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
basic_string(initializer_list<_CharT> __il);
_LIBCPP_INLINE_VISIBILITY
basic_string(initializer_list<_CharT> __il, const _Allocator& __a);
#endif // _LIBCPP_CXX03_LANG
inline ~basic_string();
_LIBCPP_INLINE_VISIBILITY
operator __self_view() const _NOEXCEPT { return __self_view(data(), size()); }
basic_string& operator=(const basic_string& __str);
template <class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> >
basic_string& operator=(const _Tp& __t)
{__self_view __sv = __t; return assign(__sv);}
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
basic_string& operator=(basic_string&& __str)
_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
_LIBCPP_INLINE_VISIBILITY
basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
#endif
_LIBCPP_INLINE_VISIBILITY basic_string& operator=(const value_type* __s) {return assign(__s);}
#if _LIBCPP_STD_VER > 20
basic_string& operator=(nullptr_t) = delete;
#endif
basic_string& operator=(value_type __c);
#if _LIBCPP_DEBUG_LEVEL == 2
_LIBCPP_INLINE_VISIBILITY
iterator begin() _NOEXCEPT
{return iterator(this, __get_pointer());}
_LIBCPP_INLINE_VISIBILITY
const_iterator begin() const _NOEXCEPT
{return const_iterator(this, __get_pointer());}
_LIBCPP_INLINE_VISIBILITY
iterator end() _NOEXCEPT
{return iterator(this, __get_pointer() + size());}
_LIBCPP_INLINE_VISIBILITY
const_iterator end() const _NOEXCEPT
{return const_iterator(this, __get_pointer() + size());}
#else
_LIBCPP_INLINE_VISIBILITY
iterator begin() _NOEXCEPT
{return iterator(__get_pointer());}
_LIBCPP_INLINE_VISIBILITY
const_iterator begin() const _NOEXCEPT
{return const_iterator(__get_pointer());}
_LIBCPP_INLINE_VISIBILITY
iterator end() _NOEXCEPT
{return iterator(__get_pointer() + size());}
_LIBCPP_INLINE_VISIBILITY
const_iterator end() const _NOEXCEPT
{return const_iterator(__get_pointer() + size());}
#endif // _LIBCPP_DEBUG_LEVEL == 2
_LIBCPP_INLINE_VISIBILITY
reverse_iterator rbegin() _NOEXCEPT
{return reverse_iterator(end());}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator rbegin() const _NOEXCEPT
{return const_reverse_iterator(end());}
_LIBCPP_INLINE_VISIBILITY
reverse_iterator rend() _NOEXCEPT
{return reverse_iterator(begin());}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator rend() const _NOEXCEPT
{return const_reverse_iterator(begin());}
_LIBCPP_INLINE_VISIBILITY
const_iterator cbegin() const _NOEXCEPT
{return begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator cend() const _NOEXCEPT
{return end();}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator crbegin() const _NOEXCEPT
{return rbegin();}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator crend() const _NOEXCEPT
{return rend();}
_LIBCPP_INLINE_VISIBILITY size_type size() const _NOEXCEPT
{return __is_long() ? __get_long_size() : __get_short_size();}
_LIBCPP_INLINE_VISIBILITY size_type length() const _NOEXCEPT {return size();}
_LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY size_type capacity() const _NOEXCEPT
{return (__is_long() ? __get_long_cap()
: static_cast<size_type>(__min_cap)) - 1;}
void resize(size_type __n, value_type __c);
_LIBCPP_INLINE_VISIBILITY void resize(size_type __n) {resize(__n, value_type());}
void reserve(size_type __requested_capacity);
#if _LIBCPP_STD_VER > 20
template <class _Op>
_LIBCPP_HIDE_FROM_ABI constexpr
void resize_and_overwrite(size_type __n, _Op __op) {
__resize_default_init(__n);
__erase_to_end(_VSTD::move(__op)(data(), _LIBCPP_AUTO_CAST(__n)));
}
#endif
_LIBCPP_INLINE_VISIBILITY void __resize_default_init(size_type __n);
_LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_INLINE_VISIBILITY
void reserve() _NOEXCEPT {shrink_to_fit();}
_LIBCPP_INLINE_VISIBILITY
void shrink_to_fit() _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
void clear() _NOEXCEPT;
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
bool empty() const _NOEXCEPT {return size() == 0;}
_LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __pos) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY reference operator[](size_type __pos) _NOEXCEPT;
const_reference at(size_type __n) const;
reference at(size_type __n);
_LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const basic_string& __str) {return append(__str);}
template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
&& !__is_same_uncvref<_Tp, basic_string >::value,
basic_string&
>
operator+=(const _Tp& __t) {__self_view __sv = __t; return append(__sv);}
_LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const value_type* __s) {return append(__s);}
_LIBCPP_INLINE_VISIBILITY basic_string& operator+=(value_type __c) {push_back(__c); return *this;}
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY basic_string& operator+=(initializer_list<value_type> __il) {return append(__il);}
#endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
basic_string& append(const basic_string& __str);
template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
&& !__is_same_uncvref<_Tp, basic_string>::value,
basic_string&
>
append(const _Tp& __t) { __self_view __sv = __t; return append(__sv.data(), __sv.size()); }
basic_string& append(const basic_string& __str, size_type __pos, size_type __n=npos);
template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
&& !__is_same_uncvref<_Tp, basic_string>::value,
basic_string&
>
append(const _Tp& __t, size_type __pos, size_type __n=npos);
basic_string& append(const value_type* __s, size_type __n);
basic_string& append(const value_type* __s);
basic_string& append(size_type __n, value_type __c);
_LIBCPP_INLINE_VISIBILITY
void __append_default_init(size_type __n);
template<class _InputIterator>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__is_exactly_cpp17_input_iterator<_InputIterator>::value,
basic_string&
>
_LIBCPP_INLINE_VISIBILITY
append(_InputIterator __first, _InputIterator __last) {
const basic_string __temp(__first, __last, __alloc());
append(__temp.data(), __temp.size());
return *this;
}
template<class _ForwardIterator>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__is_cpp17_forward_iterator<_ForwardIterator>::value,
basic_string&
>
_LIBCPP_INLINE_VISIBILITY
append(_ForwardIterator __first, _ForwardIterator __last);
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
basic_string& append(initializer_list<value_type> __il) {return append(__il.begin(), __il.size());}
#endif // _LIBCPP_CXX03_LANG
void push_back(value_type __c);
_LIBCPP_INLINE_VISIBILITY
void pop_back();
_LIBCPP_INLINE_VISIBILITY reference front() _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY const_reference front() const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY reference back() _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY const_reference back() const _NOEXCEPT;
template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
basic_string&
>
assign(const _Tp & __t) { __self_view __sv = __t; return assign(__sv.data(), __sv.size()); }
_LIBCPP_INLINE_VISIBILITY
basic_string& assign(const basic_string& __str) { return *this = __str; }
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
basic_string& assign(basic_string&& __str)
_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
{*this = _VSTD::move(__str); return *this;}
#endif
basic_string& assign(const basic_string& __str, size_type __pos, size_type __n=npos);
template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
&& !__is_same_uncvref<_Tp, basic_string>::value,
basic_string&
>
assign(const _Tp & __t, size_type __pos, size_type __n=npos);
basic_string& assign(const value_type* __s, size_type __n);
basic_string& assign(const value_type* __s);
basic_string& assign(size_type __n, value_type __c);
template<class _InputIterator>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__is_exactly_cpp17_input_iterator<_InputIterator>::value,
basic_string&
>
assign(_InputIterator __first, _InputIterator __last);
template<class _ForwardIterator>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__is_cpp17_forward_iterator<_ForwardIterator>::value,
basic_string&
>
assign(_ForwardIterator __first, _ForwardIterator __last);
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
basic_string& assign(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
#endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
basic_string& insert(size_type __pos1, const basic_string& __str);
template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
basic_string&
>
insert(size_type __pos1, const _Tp& __t)
{ __self_view __sv = __t; return insert(__pos1, __sv.data(), __sv.size()); }
template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value,
basic_string&
>
insert(size_type __pos1, const _Tp& __t, size_type __pos2, size_type __n=npos);
basic_string& insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n=npos);
basic_string& insert(size_type __pos, const value_type* __s, size_type __n);
basic_string& insert(size_type __pos, const value_type* __s);
basic_string& insert(size_type __pos, size_type __n, value_type __c);
iterator insert(const_iterator __pos, value_type __c);
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __pos, size_type __n, value_type __c);
template<class _InputIterator>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__is_exactly_cpp17_input_iterator<_InputIterator>::value,
iterator
>
insert(const_iterator __pos, _InputIterator __first, _InputIterator __last);
template<class _ForwardIterator>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__is_cpp17_forward_iterator<_ForwardIterator>::value,
iterator
>
insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last);
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __pos, initializer_list<value_type> __il)
{return insert(__pos, __il.begin(), __il.end());}
#endif // _LIBCPP_CXX03_LANG
basic_string& erase(size_type __pos = 0, size_type __n = npos);
_LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __pos);
_LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __first, const_iterator __last);
_LIBCPP_INLINE_VISIBILITY
basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str);
template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
basic_string&
>
replace(size_type __pos1, size_type __n1, const _Tp& __t) { __self_view __sv = __t; return replace(__pos1, __n1, __sv.data(), __sv.size()); }
basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2=npos);
template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value,
basic_string&
>
replace(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos);
basic_string& replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2);
basic_string& replace(size_type __pos, size_type __n1, const value_type* __s);
basic_string& replace(size_type __pos, size_type __n1, size_type __n2, value_type __c);
_LIBCPP_INLINE_VISIBILITY
basic_string& replace(const_iterator __i1, const_iterator __i2, const basic_string& __str);
template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
basic_string&
>
replace(const_iterator __i1, const_iterator __i2, const _Tp& __t) { __self_view __sv = __t; return replace(__i1 - begin(), __i2 - __i1, __sv); }
_LIBCPP_INLINE_VISIBILITY
basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n);
_LIBCPP_INLINE_VISIBILITY
basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s);
_LIBCPP_INLINE_VISIBILITY
basic_string& replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c);
template<class _InputIterator>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__is_cpp17_input_iterator<_InputIterator>::value,
basic_string&
>
replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2);
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<value_type> __il)
{return replace(__i1, __i2, __il.begin(), __il.end());}
#endif // _LIBCPP_CXX03_LANG
size_type copy(value_type* __s, size_type __n, size_type __pos = 0) const;
_LIBCPP_INLINE_VISIBILITY
basic_string substr(size_type __pos = 0, size_type __n = npos) const;
_LIBCPP_INLINE_VISIBILITY
void swap(basic_string& __str)
#if _LIBCPP_STD_VER >= 14
_NOEXCEPT;
#else
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
__is_nothrow_swappable<allocator_type>::value);
#endif
_LIBCPP_INLINE_VISIBILITY
const value_type* c_str() const _NOEXCEPT {return data();}
_LIBCPP_INLINE_VISIBILITY
const value_type* data() const _NOEXCEPT {return _VSTD::__to_address(__get_pointer());}
#if _LIBCPP_STD_VER > 14 || defined(_LIBCPP_BUILDING_LIBRARY)
_LIBCPP_INLINE_VISIBILITY
value_type* data() _NOEXCEPT {return _VSTD::__to_address(__get_pointer());}
#endif
_LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const _NOEXCEPT {return __alloc();}
_LIBCPP_INLINE_VISIBILITY
size_type find(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
size_type
>
find(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT;
size_type find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
size_type find(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
size_type find(value_type __c, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
size_type rfind(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
size_type
>
rfind(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
size_type rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
size_type rfind(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
size_type rfind(value_type __c, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
size_type find_first_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
size_type
>
find_first_of(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT;
size_type find_first_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
size_type find_first_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
size_type find_first_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
size_type find_last_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
size_type
>
find_last_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
size_type find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
size_type find_last_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
size_type find_last_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
size_type
>
find_first_not_of(const _Tp &__t, size_type __pos = 0) const _NOEXCEPT;
size_type find_first_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
size_type find_first_not_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
size_type find_first_not_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
size_type
>
find_last_not_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
size_type find_last_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
int compare(const basic_string& __str) const _NOEXCEPT;
template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
int
>
compare(const _Tp &__t) const _NOEXCEPT;
template <class _Tp>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
int
>
compare(size_type __pos1, size_type __n1, const _Tp& __t) const;
_LIBCPP_INLINE_VISIBILITY
int compare(size_type __pos1, size_type __n1, const basic_string& __str) const;
int compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2=npos) const;
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value,
int
>
compare(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos) const;
int compare(const value_type* __s) const _NOEXCEPT;
int compare(size_type __pos1, size_type __n1, const value_type* __s) const;
int compare(size_type __pos1, size_type __n1, const value_type* __s, size_type __n2) const;
#if _LIBCPP_STD_VER > 17
constexpr _LIBCPP_INLINE_VISIBILITY
bool starts_with(__self_view __sv) const noexcept
{ return __self_view(data(), size()).starts_with(__sv); }
constexpr _LIBCPP_INLINE_VISIBILITY
bool starts_with(value_type __c) const noexcept
{ return !empty() && _Traits::eq(front(), __c); }
constexpr _LIBCPP_INLINE_VISIBILITY
bool starts_with(const value_type* __s) const noexcept
{ return starts_with(__self_view(__s)); }
constexpr _LIBCPP_INLINE_VISIBILITY
bool ends_with(__self_view __sv) const noexcept
{ return __self_view(data(), size()).ends_with( __sv); }
constexpr _LIBCPP_INLINE_VISIBILITY
bool ends_with(value_type __c) const noexcept
{ return !empty() && _Traits::eq(back(), __c); }
constexpr _LIBCPP_INLINE_VISIBILITY
bool ends_with(const value_type* __s) const noexcept
{ return ends_with(__self_view(__s)); }
#endif
#if _LIBCPP_STD_VER > 20
constexpr _LIBCPP_INLINE_VISIBILITY
bool contains(__self_view __sv) const noexcept
{ return __self_view(data(), size()).contains(__sv); }
constexpr _LIBCPP_INLINE_VISIBILITY
bool contains(value_type __c) const noexcept
{ return __self_view(data(), size()).contains(__c); }
constexpr _LIBCPP_INLINE_VISIBILITY
bool contains(const value_type* __s) const
{ return __self_view(data(), size()).contains(__s); }
#endif
_LIBCPP_INLINE_VISIBILITY bool __invariants() const;
_LIBCPP_INLINE_VISIBILITY void __clear_and_shrink() _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY void __shrink_or_extend(size_type __target_capacity);
_LIBCPP_INLINE_VISIBILITY
bool __is_long() const _NOEXCEPT
{return bool(__r_.first().__s.__size_ & __short_mask);}
#if _LIBCPP_DEBUG_LEVEL == 2
bool __dereferenceable(const const_iterator* __i) const;
bool __decrementable(const const_iterator* __i) const;
bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
#endif // _LIBCPP_DEBUG_LEVEL == 2
private:
_LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI static bool __fits_in_sso(size_type __sz) {
// SSO is disabled during constant evaluation because `__is_long` isn't constexpr friendly
return !__libcpp_is_constant_evaluated() && (__sz < __min_cap);
}
_LIBCPP_INLINE_VISIBILITY
allocator_type& __alloc() _NOEXCEPT
{return __r_.second();}
_LIBCPP_INLINE_VISIBILITY
const allocator_type& __alloc() const _NOEXCEPT
{return __r_.second();}
#ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
_LIBCPP_INLINE_VISIBILITY
void __set_short_size(size_type __s) _NOEXCEPT
# ifdef _LIBCPP_BIG_ENDIAN
{__r_.first().__s.__size_ = (unsigned char)(__s << 1);}
# else
{__r_.first().__s.__size_ = (unsigned char)(__s);}
# endif
_LIBCPP_INLINE_VISIBILITY
size_type __get_short_size() const _NOEXCEPT
# ifdef _LIBCPP_BIG_ENDIAN
{return __r_.first().__s.__size_ >> 1;}
# else
{return __r_.first().__s.__size_;}
# endif
#else // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
_LIBCPP_INLINE_VISIBILITY
void __set_short_size(size_type __s) _NOEXCEPT
# ifdef _LIBCPP_BIG_ENDIAN
{__r_.first().__s.__size_ = (unsigned char)(__s);}
# else
{__r_.first().__s.__size_ = (unsigned char)(__s << 1);}
# endif
_LIBCPP_INLINE_VISIBILITY
size_type __get_short_size() const _NOEXCEPT
# ifdef _LIBCPP_BIG_ENDIAN
{return __r_.first().__s.__size_;}
# else
{return __r_.first().__s.__size_ >> 1;}
# endif
#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
_LIBCPP_INLINE_VISIBILITY
void __set_long_size(size_type __s) _NOEXCEPT
{__r_.first().__l.__size_ = __s;}
_LIBCPP_INLINE_VISIBILITY
size_type __get_long_size() const _NOEXCEPT
{return __r_.first().__l.__size_;}
_LIBCPP_INLINE_VISIBILITY
void __set_size(size_type __s) _NOEXCEPT
{if (__is_long()) __set_long_size(__s); else __set_short_size(__s);}
_LIBCPP_INLINE_VISIBILITY
void __set_long_cap(size_type __s) _NOEXCEPT
{__r_.first().__l.__cap_ = __long_mask | __s;}
_LIBCPP_INLINE_VISIBILITY
size_type __get_long_cap() const _NOEXCEPT
{return __r_.first().__l.__cap_ & size_type(~__long_mask);}
_LIBCPP_INLINE_VISIBILITY
void __set_long_pointer(pointer __p) _NOEXCEPT
{__r_.first().__l.__data_ = __p;}
_LIBCPP_INLINE_VISIBILITY
pointer __get_long_pointer() _NOEXCEPT
{return __r_.first().__l.__data_;}
_LIBCPP_INLINE_VISIBILITY
const_pointer __get_long_pointer() const _NOEXCEPT
{return __r_.first().__l.__data_;}
_LIBCPP_INLINE_VISIBILITY
pointer __get_short_pointer() _NOEXCEPT
{return pointer_traits<pointer>::pointer_to(__r_.first().__s.__data_[0]);}
_LIBCPP_INLINE_VISIBILITY
const_pointer __get_short_pointer() const _NOEXCEPT
{return pointer_traits<const_pointer>::pointer_to(__r_.first().__s.__data_[0]);}
_LIBCPP_INLINE_VISIBILITY
pointer __get_pointer() _NOEXCEPT
{return __is_long() ? __get_long_pointer() : __get_short_pointer();}
_LIBCPP_INLINE_VISIBILITY
const_pointer __get_pointer() const _NOEXCEPT
{return __is_long() ? __get_long_pointer() : __get_short_pointer();}
_LIBCPP_INLINE_VISIBILITY
void __zero() _NOEXCEPT
{
size_type (&__a)[__n_words] = __r_.first().__r.__words;
for (unsigned __i = 0; __i < __n_words; ++__i)
__a[__i] = 0;
}
template <size_type __a> static
_LIBCPP_INLINE_VISIBILITY
size_type __align_it(size_type __s) _NOEXCEPT
{return (__s + (__a-1)) & ~(__a-1);}
enum {__alignment = 16};
static _LIBCPP_INLINE_VISIBILITY
size_type __recommend(size_type __s) _NOEXCEPT
{
if (__s < __min_cap) return static_cast<size_type>(__min_cap) - 1;
size_type __guess = __align_it<sizeof(value_type) < __alignment ?
__alignment/sizeof(value_type) : 1 > (__s+1) - 1;
if (__guess == __min_cap) ++__guess;
return __guess;
}
inline
void __init(const value_type* __s, size_type __sz, size_type __reserve);
inline
void __init(const value_type* __s, size_type __sz);
inline
void __init(size_type __n, value_type __c);
// Slow path for the (inlined) copy constructor for 'long' strings.
// Always externally instantiated and not inlined.
// Requires that __s is zero terminated.
// The main reason for this function to exist is because for unstable, we
// want to allow inlining of the copy constructor. However, we don't want
// to call the __init() functions as those are marked as inline which may
// result in over-aggressive inlining by the compiler, where our aim is
// to only inline the fast path code directly in the ctor.
void __init_copy_ctor_external(const value_type* __s, size_type __sz);
template <class _InputIterator>
inline
__enable_if_t
<
__is_exactly_cpp17_input_iterator<_InputIterator>::value
>
__init(_InputIterator __first, _InputIterator __last);
template <class _ForwardIterator>
inline
__enable_if_t
<
__is_cpp17_forward_iterator<_ForwardIterator>::value
>
__init(_ForwardIterator __first, _ForwardIterator __last);
void __grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
size_type __n_copy, size_type __n_del, size_type __n_add = 0);
void __grow_by_and_replace(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
size_type __n_copy, size_type __n_del,
size_type __n_add, const value_type* __p_new_stuff);
// __assign_no_alias is invoked for assignment operations where we
// have proof that the input does not alias the current instance.
// For example, operator=(basic_string) performs a 'self' check.
template <bool __is_short>
basic_string& __assign_no_alias(const value_type* __s, size_type __n);
_LIBCPP_INLINE_VISIBILITY
void __erase_to_end(size_type __pos);
// __erase_external_with_move is invoked for erase() invocations where
// `n ~= npos`, likely requiring memory moves on the string data.
void __erase_external_with_move(size_type __pos, size_type __n);
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const basic_string& __str)
{__copy_assign_alloc(__str, integral_constant<bool,
__alloc_traits::propagate_on_container_copy_assignment::value>());}
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const basic_string& __str, true_type)
{
if (__alloc() == __str.__alloc())
__alloc() = __str.__alloc();
else
{
if (!__str.__is_long())
{
__clear_and_shrink();
__alloc() = __str.__alloc();
}
else
{
allocator_type __a = __str.__alloc();
pointer __p = __alloc_traits::allocate(__a, __str.__get_long_cap());
__clear_and_shrink();
__alloc() = _VSTD::move(__a);
__set_long_pointer(__p);
__set_long_cap(__str.__get_long_cap());
__set_long_size(__str.size());
}
}
}
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const basic_string&, false_type) _NOEXCEPT
{}
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
void __move_assign(basic_string& __str, false_type)
_NOEXCEPT_(__alloc_traits::is_always_equal::value);
_LIBCPP_INLINE_VISIBILITY
void __move_assign(basic_string& __str, true_type)
#if _LIBCPP_STD_VER > 14
_NOEXCEPT;
#else
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
#endif
#endif
_LIBCPP_INLINE_VISIBILITY
void
__move_assign_alloc(basic_string& __str)
_NOEXCEPT_(
!__alloc_traits::propagate_on_container_move_assignment::value ||
is_nothrow_move_assignable<allocator_type>::value)
{__move_assign_alloc(__str, integral_constant<bool,
__alloc_traits::propagate_on_container_move_assignment::value>());}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(basic_string& __c, true_type)
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
{
__alloc() = _VSTD::move(__c.__alloc());
}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(basic_string&, false_type)
_NOEXCEPT
{}
basic_string& __assign_external(const value_type* __s);
basic_string& __assign_external(const value_type* __s, size_type __n);
// Assigns the value in __s, guaranteed to be __n < __min_cap in length.
inline basic_string& __assign_short(const value_type* __s, size_type __n) {
pointer __p = __is_long()
? (__set_long_size(__n), __get_long_pointer())
: (__set_short_size(__n), __get_short_pointer());
traits_type::move(_VSTD::__to_address(__p), __s, __n);
traits_type::assign(__p[__n], value_type());
return *this;
}
_LIBCPP_HIDE_FROM_ABI basic_string& __null_terminate_at(value_type* __p, size_type __newsz) {
__set_size(__newsz);
__invalidate_iterators_past(__newsz);
traits_type::assign(__p[__newsz], value_type());
return *this;
}
_LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
_LIBCPP_INLINE_VISIBILITY void __invalidate_iterators_past(size_type);
template<class _Tp>
_LIBCPP_INLINE_VISIBILITY
bool __addr_in_range(_Tp&& __t) const {
const volatile void *__p = _VSTD::addressof(__t);
return data() <= __p && __p <= data() + size();
}
_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
void __throw_length_error() const {
_VSTD::__throw_length_error("basic_string");
}
_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
void __throw_out_of_range() const {
_VSTD::__throw_out_of_range("basic_string");
}
friend basic_string operator+<>(const basic_string&, const basic_string&);
friend basic_string operator+<>(const value_type*, const basic_string&);
friend basic_string operator+<>(value_type, const basic_string&);
friend basic_string operator+<>(const basic_string&, const value_type*);
friend basic_string operator+<>(const basic_string&, value_type);
};
// These declarations must appear before any functions are implicitly used
// so that they have the correct visibility specifier.
#ifdef _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
_LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, char)
# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, wchar_t)
# endif
#else
_LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, char)
# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, wchar_t)
# endif
#endif
#if _LIBCPP_STD_VER >= 17
template<class _InputIterator,
class _CharT = __iter_value_type<_InputIterator>,
class _Allocator = allocator<_CharT>,
class = enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
class = enable_if_t<__is_allocator<_Allocator>::value>
>
basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
-> basic_string<_CharT, char_traits<_CharT>, _Allocator>;
template<class _CharT,
class _Traits,
class _Allocator = allocator<_CharT>,
class = enable_if_t<__is_allocator<_Allocator>::value>
>
explicit basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator())
-> basic_string<_CharT, _Traits, _Allocator>;
template<class _CharT,
class _Traits,
class _Allocator = allocator<_CharT>,
class = enable_if_t<__is_allocator<_Allocator>::value>,
class _Sz = typename allocator_traits<_Allocator>::size_type
>
basic_string(basic_string_view<_CharT, _Traits>, _Sz, _Sz, const _Allocator& = _Allocator())
-> basic_string<_CharT, _Traits, _Allocator>;
#endif
template <class _CharT, class _Traits, class _Allocator>
inline
void
basic_string<_CharT, _Traits, _Allocator>::__invalidate_all_iterators()
{
#if _LIBCPP_DEBUG_LEVEL == 2
if (!__libcpp_is_constant_evaluated())
__get_db()->__invalidate_all(this);
#endif
}
template <class _CharT, class _Traits, class _Allocator>
inline
void
basic_string<_CharT, _Traits, _Allocator>::__invalidate_iterators_past(size_type __pos)
{
#if _LIBCPP_DEBUG_LEVEL == 2
if (!__libcpp_is_constant_evaluated()) {
__c_node* __c = __get_db()->__find_c_and_lock(this);
if (__c)
{
const_pointer __new_last = __get_pointer() + __pos;
for (__i_node** __p = __c->end_; __p != __c->beg_; )
{
--__p;
const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_);
if (__i->base() > __new_last)
{
(*__p)->__c_ = nullptr;
if (--__c->end_ != __p)
_VSTD::memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*));
}
}
__get_db()->unlock();
}
}
#else
(void)__pos;
#endif // _LIBCPP_DEBUG_LEVEL == 2
}
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>::basic_string()
_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
: __r_(__default_init_tag(), __default_init_tag())
{
_VSTD::__debug_db_insert_c(this);
__zero();
}
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>::basic_string(const allocator_type& __a)
#if _LIBCPP_STD_VER <= 14
_NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
#else
_NOEXCEPT
#endif
: __r_(__default_init_tag(), __a)
{
_VSTD::__debug_db_insert_c(this);
__zero();
}
template <class _CharT, class _Traits, class _Allocator>
void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s,
size_type __sz,
size_type __reserve)
{
if (__reserve > max_size())
__throw_length_error();
pointer __p;
if (__fits_in_sso(__reserve))
{
__set_short_size(__sz);
__p = __get_short_pointer();
}
else
{
size_type __cap = __recommend(__reserve);
__p = __alloc_traits::allocate(__alloc(), __cap+1);
__set_long_pointer(__p);
__set_long_cap(__cap+1);
__set_long_size(__sz);
}
traits_type::copy(_VSTD::__to_address(__p), __s, __sz);
traits_type::assign(__p[__sz], value_type());
}
template <class _CharT, class _Traits, class _Allocator>
void
basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz)
{
if (__sz > max_size())
__throw_length_error();
pointer __p;
if (__fits_in_sso(__sz))
{
__set_short_size(__sz);
__p = __get_short_pointer();
}
else
{
size_type __cap = __recommend(__sz);
__p = __alloc_traits::allocate(__alloc(), __cap+1);
__set_long_pointer(__p);
__set_long_cap(__cap+1);
__set_long_size(__sz);
}
traits_type::copy(_VSTD::__to_address(__p), __s, __sz);
traits_type::assign(__p[__sz], value_type());
}
template <class _CharT, class _Traits, class _Allocator>
template <class>
basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, const _Allocator& __a)
: __r_(__default_init_tag(), __a)
{
_LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr");
__init(__s, traits_type::length(__s));
_VSTD::__debug_db_insert_c(this);
}
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n)
: __r_(__default_init_tag(), __default_init_tag())
{
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n) detected nullptr");
__init(__s, __n);
_VSTD::__debug_db_insert_c(this);
}
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n, const _Allocator& __a)
: __r_(__default_init_tag(), __a)
{
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr");
__init(__s, __n);
_VSTD::__debug_db_insert_c(this);
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str)
: __r_(__default_init_tag(), __alloc_traits::select_on_container_copy_construction(__str.__alloc()))
{
if (!__str.__is_long())
__r_.first().__r = __str.__r_.first().__r;
else
__init_copy_ctor_external(_VSTD::__to_address(__str.__get_long_pointer()),
__str.__get_long_size());
_VSTD::__debug_db_insert_c(this);
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>::basic_string(
const basic_string& __str, const allocator_type& __a)
: __r_(__default_init_tag(), __a)
{
if (!__str.__is_long())
__r_.first().__r = __str.__r_.first().__r;
else
__init_copy_ctor_external(_VSTD::__to_address(__str.__get_long_pointer()),
__str.__get_long_size());
_VSTD::__debug_db_insert_c(this);
}
template <class _CharT, class _Traits, class _Allocator>
void basic_string<_CharT, _Traits, _Allocator>::__init_copy_ctor_external(
const value_type* __s, size_type __sz) {
pointer __p;
if (__fits_in_sso(__sz)) {
__p = __get_short_pointer();
__set_short_size(__sz);
} else {
if (__sz > max_size())
__throw_length_error();
size_t __cap = __recommend(__sz);
__p = __alloc_traits::allocate(__alloc(), __cap + 1);
__set_long_pointer(__p);
__set_long_cap(__cap + 1);
__set_long_size(__sz);
}
traits_type::copy(_VSTD::__to_address(__p), __s, __sz + 1);
}
#ifndef _LIBCPP_CXX03_LANG
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str)
#if _LIBCPP_STD_VER <= 14
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
#else
_NOEXCEPT
#endif
: __r_(_VSTD::move(__str.__r_))
{
__str.__zero();
_VSTD::__debug_db_insert_c(this);
#if _LIBCPP_DEBUG_LEVEL == 2
if (!__libcpp_is_constant_evaluated() && __is_long())
__get_db()->swap(this, &__str);
#endif
}
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a)
: __r_(__default_init_tag(), __a)
{
if (__str.__is_long() && __a != __str.__alloc()) // copy, not move
__init(_VSTD::__to_address(__str.__get_long_pointer()), __str.__get_long_size());
else
{
__r_.first().__r = __str.__r_.first().__r;
__str.__zero();
}
_VSTD::__debug_db_insert_c(this);
#if _LIBCPP_DEBUG_LEVEL == 2
if (!__libcpp_is_constant_evaluated() && __is_long())
__get_db()->swap(this, &__str);
#endif
}
#endif // _LIBCPP_CXX03_LANG
template <class _CharT, class _Traits, class _Allocator>
void
basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c)
{
if (__n > max_size())
__throw_length_error();
pointer __p;
if (__fits_in_sso(__n))
{
__set_short_size(__n);
__p = __get_short_pointer();
}
else
{
size_type __cap = __recommend(__n);
__p = __alloc_traits::allocate(__alloc(), __cap+1);
__set_long_pointer(__p);
__set_long_cap(__cap+1);
__set_long_size(__n);
}
traits_type::assign(_VSTD::__to_address(__p), __n, __c);
traits_type::assign(__p[__n], value_type());
}
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c)
: __r_(__default_init_tag(), __default_init_tag())
{
__init(__n, __c);
_VSTD::__debug_db_insert_c(this);
}
template <class _CharT, class _Traits, class _Allocator>
template <class>
basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c, const _Allocator& __a)
: __r_(__default_init_tag(), __a)
{
__init(__n, __c);
_VSTD::__debug_db_insert_c(this);
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str,
size_type __pos, size_type __n,
const _Allocator& __a)
: __r_(__default_init_tag(), __a)
{
size_type __str_sz = __str.size();
if (__pos > __str_sz)
__throw_out_of_range();
__init(__str.data() + __pos, _VSTD::min(__n, __str_sz - __pos));
_VSTD::__debug_db_insert_c(this);
}
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos,
const _Allocator& __a)
: __r_(__default_init_tag(), __a)
{
size_type __str_sz = __str.size();
if (__pos > __str_sz)
__throw_out_of_range();
__init(__str.data() + __pos, __str_sz - __pos);
_VSTD::__debug_db_insert_c(this);
}
template <class _CharT, class _Traits, class _Allocator>
template <class _Tp, class>
basic_string<_CharT, _Traits, _Allocator>::basic_string(
const _Tp& __t, size_type __pos, size_type __n, const allocator_type& __a)
: __r_(__default_init_tag(), __a)
{
__self_view __sv0 = __t;
__self_view __sv = __sv0.substr(__pos, __n);
__init(__sv.data(), __sv.size());
_VSTD::__debug_db_insert_c(this);
}
template <class _CharT, class _Traits, class _Allocator>
template <class _Tp, class>
basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t)
: __r_(__default_init_tag(), __default_init_tag())
{
__self_view __sv = __t;
__init(__sv.data(), __sv.size());
_VSTD::__debug_db_insert_c(this);
}
template <class _CharT, class _Traits, class _Allocator>
template <class _Tp, class>
basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t, const _Allocator& __a)
: __r_(__default_init_tag(), __a)
{
__self_view __sv = __t;
__init(__sv.data(), __sv.size());
_VSTD::__debug_db_insert_c(this);
}
template <class _CharT, class _Traits, class _Allocator>
template <class _InputIterator>
__enable_if_t
<
__is_exactly_cpp17_input_iterator<_InputIterator>::value
>
basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last)
{
__zero();
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
for (; __first != __last; ++__first)
push_back(*__first);
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
if (__is_long())
__alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
}
template <class _CharT, class _Traits, class _Allocator>
template <class _ForwardIterator>
__enable_if_t
<
__is_cpp17_forward_iterator<_ForwardIterator>::value
>
basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last)
{
size_type __sz = static_cast<size_type>(_VSTD::distance(__first, __last));
if (__sz > max_size())
__throw_length_error();
pointer __p;
if (__fits_in_sso(__sz))
{
__set_short_size(__sz);
__p = __get_short_pointer();
}
else
{
size_type __cap = __recommend(__sz);
__p = __alloc_traits::allocate(__alloc(), __cap+1);
__set_long_pointer(__p);
__set_long_cap(__cap+1);
__set_long_size(__sz);
}
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
for (; __first != __last; ++__first, (void) ++__p)
traits_type::assign(*__p, *__first);
traits_type::assign(*__p, value_type());
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
if (__is_long())
__alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
}
template <class _CharT, class _Traits, class _Allocator>
template<class _InputIterator, class>
inline
basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last)
: __r_(__default_init_tag(), __default_init_tag())
{
__init(__first, __last);
_VSTD::__debug_db_insert_c(this);
}
template <class _CharT, class _Traits, class _Allocator>
template<class _InputIterator, class>
inline
basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last,
const allocator_type& __a)
: __r_(__default_init_tag(), __a)
{
__init(__first, __last);
_VSTD::__debug_db_insert_c(this);
}
#ifndef _LIBCPP_CXX03_LANG
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>::basic_string(
initializer_list<_CharT> __il)
: __r_(__default_init_tag(), __default_init_tag())
{
__init(__il.begin(), __il.end());
_VSTD::__debug_db_insert_c(this);
}
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>::basic_string(
initializer_list<_CharT> __il, const _Allocator& __a)
: __r_(__default_init_tag(), __a)
{
__init(__il.begin(), __il.end());
_VSTD::__debug_db_insert_c(this);
}
#endif // _LIBCPP_CXX03_LANG
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>::~basic_string()
{
#if _LIBCPP_DEBUG_LEVEL == 2
if (!__libcpp_is_constant_evaluated())
__get_db()->__erase_c(this);
#endif
if (__is_long())
__alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
}
template <class _CharT, class _Traits, class _Allocator>
void
basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace
(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
size_type __n_copy, size_type __n_del, size_type __n_add, const value_type* __p_new_stuff)
{
size_type __ms = max_size();
if (__delta_cap > __ms - __old_cap - 1)
__throw_length_error();
pointer __old_p = __get_pointer();
size_type __cap = __old_cap < __ms / 2 - __alignment ?
__recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
__ms - 1;
pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
__invalidate_all_iterators();
if (__n_copy != 0)
traits_type::copy(_VSTD::__to_address(__p),
_VSTD::__to_address(__old_p), __n_copy);
if (__n_add != 0)
traits_type::copy(_VSTD::__to_address(__p) + __n_copy, __p_new_stuff, __n_add);
size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
if (__sec_cp_sz != 0)
traits_type::copy(_VSTD::__to_address(__p) + __n_copy + __n_add,
_VSTD::__to_address(__old_p) + __n_copy + __n_del, __sec_cp_sz);
if (__old_cap+1 != __min_cap)
__alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
__set_long_pointer(__p);
__set_long_cap(__cap+1);
__old_sz = __n_copy + __n_add + __sec_cp_sz;
__set_long_size(__old_sz);
traits_type::assign(__p[__old_sz], value_type());
}
template <class _CharT, class _Traits, class _Allocator>
void
basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
size_type __n_copy, size_type __n_del, size_type __n_add)
{
size_type __ms = max_size();
if (__delta_cap > __ms - __old_cap)
__throw_length_error();
pointer __old_p = __get_pointer();
size_type __cap = __old_cap < __ms / 2 - __alignment ?
__recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
__ms - 1;
pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
__invalidate_all_iterators();
if (__n_copy != 0)
traits_type::copy(_VSTD::__to_address(__p),
_VSTD::__to_address(__old_p), __n_copy);
size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
if (__sec_cp_sz != 0)
traits_type::copy(_VSTD::__to_address(__p) + __n_copy + __n_add,
_VSTD::__to_address(__old_p) + __n_copy + __n_del,
__sec_cp_sz);
if (__old_cap+1 != __min_cap)
__alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
__set_long_pointer(__p);
__set_long_cap(__cap+1);
}
// assign
template <class _CharT, class _Traits, class _Allocator>
template <bool __is_short>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::__assign_no_alias(
const value_type* __s, size_type __n) {
size_type __cap = __is_short ? __min_cap : __get_long_cap();
if (__n < __cap) {
pointer __p = __is_short ? __get_short_pointer() : __get_long_pointer();
__is_short ? __set_short_size(__n) : __set_long_size(__n);
traits_type::copy(_VSTD::__to_address(__p), __s, __n);
traits_type::assign(__p[__n], value_type());
__invalidate_iterators_past(__n);
} else {
size_type __sz = __is_short ? __get_short_size() : __get_long_size();
__grow_by_and_replace(__cap - 1, __n - __cap + 1, __sz, 0, __sz, __n, __s);
}
return *this;
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::__assign_external(
const value_type* __s, size_type __n) {
size_type __cap = capacity();
if (__cap >= __n) {
value_type* __p = _VSTD::__to_address(__get_pointer());
traits_type::move(__p, __s, __n);
return __null_terminate_at(__p, __n);
} else {
size_type __sz = size();
__grow_by_and_replace(__cap, __n - __cap, __sz, 0, __sz, __n, __s);
return *this;
}
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_type __n)
{
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::assign received nullptr");
return (__builtin_constant_p(__n) && __fits_in_sso(__n))
? __assign_short(__s, __n)
: __assign_external(__s, __n);
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::assign(size_type __n, value_type __c)
{
size_type __cap = capacity();
if (__cap < __n)
{
size_type __sz = size();
__grow_by(__cap, __n - __cap, __sz, 0, __sz);
}
value_type* __p = _VSTD::__to_address(__get_pointer());
traits_type::assign(__p, __n, __c);
return __null_terminate_at(__p, __n);
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::operator=(value_type __c)
{
pointer __p;
if (__is_long())
{
__p = __get_long_pointer();
__set_long_size(1);
}
else
{
__p = __get_short_pointer();
__set_short_size(1);
}
traits_type::assign(*__p, __c);
traits_type::assign(*++__p, value_type());
__invalidate_iterators_past(1);
return *this;
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)
{
if (this != &__str) {
__copy_assign_alloc(__str);
if (!__is_long()) {
if (!__str.__is_long()) {
__r_.first().__r = __str.__r_.first().__r;
} else {
return __assign_no_alias<true>(__str.data(), __str.size());
}
} else {
return __assign_no_alias<false>(__str.data(), __str.size());
}
}
return *this;
}
#ifndef _LIBCPP_CXX03_LANG
template <class _CharT, class _Traits, class _Allocator>
inline
void
basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, false_type)
_NOEXCEPT_(__alloc_traits::is_always_equal::value)
{
if (__alloc() != __str.__alloc())
assign(__str);
else
__move_assign(__str, true_type());
}
template <class _CharT, class _Traits, class _Allocator>
inline
void
basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type)
#if _LIBCPP_STD_VER > 14
_NOEXCEPT
#else
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
#endif
{
if (__is_long()) {
__alloc_traits::deallocate(__alloc(), __get_long_pointer(),
__get_long_cap());
#if _LIBCPP_STD_VER <= 14
if (!is_nothrow_move_assignable<allocator_type>::value) {
__set_short_size(0);
traits_type::assign(__get_short_pointer()[0], value_type());
}
#endif
}
__move_assign_alloc(__str);
__r_.first() = __str.__r_.first();
__str.__set_short_size(0);
traits_type::assign(__str.__get_short_pointer()[0], value_type());
}
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::operator=(basic_string&& __str)
_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
{
__move_assign(__str, integral_constant<bool,
__alloc_traits::propagate_on_container_move_assignment::value>());
return *this;
}
#endif
template <class _CharT, class _Traits, class _Allocator>
template<class _InputIterator>
__enable_if_t
<
__is_exactly_cpp17_input_iterator<_InputIterator>::value,
basic_string<_CharT, _Traits, _Allocator>&
>
basic_string<_CharT, _Traits, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
{
const basic_string __temp(__first, __last, __alloc());
assign(__temp.data(), __temp.size());
return *this;
}
template <class _CharT, class _Traits, class _Allocator>
template<class _ForwardIterator>
__enable_if_t
<
__is_cpp17_forward_iterator<_ForwardIterator>::value,
basic_string<_CharT, _Traits, _Allocator>&
>
basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
{
size_type __cap = capacity();
size_type __n = __string_is_trivial_iterator<_ForwardIterator>::value ?
static_cast<size_type>(_VSTD::distance(__first, __last)) : 0;
if (__string_is_trivial_iterator<_ForwardIterator>::value &&
(__cap >= __n || !__addr_in_range(*__first)))
{
if (__cap < __n)
{
size_type __sz = size();
__grow_by(__cap, __n - __cap, __sz, 0, __sz);
}
pointer __p = __get_pointer();
for (; __first != __last; ++__p, (void) ++__first)
traits_type::assign(*__p, *__first);
traits_type::assign(*__p, value_type());
__set_size(__n);
__invalidate_iterators_past(__n);
}
else
{
const basic_string __temp(__first, __last, __alloc());
assign(__temp.data(), __temp.size());
}
return *this;
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, size_type __pos, size_type __n)
{
size_type __sz = __str.size();
if (__pos > __sz)
__throw_out_of_range();
return assign(__str.data() + __pos, _VSTD::min(__n, __sz - __pos));
}
template <class _CharT, class _Traits, class _Allocator>
template <class _Tp>
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
&& !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
basic_string<_CharT, _Traits, _Allocator>&
>
basic_string<_CharT, _Traits, _Allocator>::assign(const _Tp & __t, size_type __pos, size_type __n)
{
__self_view __sv = __t;
size_type __sz = __sv.size();
if (__pos > __sz)
__throw_out_of_range();
return assign(__sv.data() + __pos, _VSTD::min(__n, __sz - __pos));
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::__assign_external(const value_type* __s) {
return __assign_external(__s, traits_type::length(__s));
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s)
{
_LIBCPP_ASSERT(__s != nullptr, "string::assign received nullptr");
return __builtin_constant_p(*__s)
? (__fits_in_sso(traits_type::length(__s))
? __assign_short(__s, traits_type::length(__s))
: __assign_external(__s, traits_type::length(__s)))
: __assign_external(__s);
}
// append
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_type __n)
{
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::append received nullptr");
size_type __cap = capacity();
size_type __sz = size();
if (__cap - __sz >= __n)
{
if (__n)
{
value_type* __p = _VSTD::__to_address(__get_pointer());
traits_type::copy(__p + __sz, __s, __n);
__sz += __n;
__set_size(__sz);
traits_type::assign(__p[__sz], value_type());
}
}
else
__grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __sz, 0, __n, __s);
return *this;
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::append(size_type __n, value_type __c)
{
if (__n)
{
size_type __cap = capacity();
size_type __sz = size();
if (__cap - __sz < __n)
__grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
pointer __p = __get_pointer();
traits_type::assign(_VSTD::__to_address(__p) + __sz, __n, __c);
__sz += __n;
__set_size(__sz);
traits_type::assign(__p[__sz], value_type());
}
return *this;
}
template <class _CharT, class _Traits, class _Allocator>
inline void
basic_string<_CharT, _Traits, _Allocator>::__append_default_init(size_type __n)
{
if (__n)
{
size_type __cap = capacity();
size_type __sz = size();
if (__cap - __sz < __n)
__grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
pointer __p = __get_pointer();
__sz += __n;
__set_size(__sz);
traits_type::assign(__p[__sz], value_type());
}
}
template <class _CharT, class _Traits, class _Allocator>
void
basic_string<_CharT, _Traits, _Allocator>::push_back(value_type __c)
{
bool __is_short = !__is_long();
size_type __cap;
size_type __sz;
if (__is_short)
{
__cap = __min_cap - 1;
__sz = __get_short_size();
}
else
{
__cap = __get_long_cap() - 1;
__sz = __get_long_size();
}
if (__sz == __cap)
{
__grow_by(__cap, 1, __sz, __sz, 0);
__is_short = false; // the string is always long after __grow_by
}
pointer __p;
if (__is_short)
{
__p = __get_short_pointer() + __sz;
__set_short_size(__sz+1);
}
else
{
__p = __get_long_pointer() + __sz;
__set_long_size(__sz+1);
}
traits_type::assign(*__p, __c);
traits_type::assign(*++__p, value_type());
}
template <class _CharT, class _Traits, class _Allocator>
template<class _ForwardIterator>
__enable_if_t
<
__is_cpp17_forward_iterator<_ForwardIterator>::value,
basic_string<_CharT, _Traits, _Allocator>&
>
basic_string<_CharT, _Traits, _Allocator>::append(
_ForwardIterator __first, _ForwardIterator __last)
{
size_type __sz = size();
size_type __cap = capacity();
size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
if (__n)
{
if (__string_is_trivial_iterator<_ForwardIterator>::value &&
!__addr_in_range(*__first))
{
if (__cap - __sz < __n)
__grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
pointer __p = __get_pointer() + __sz;
for (; __first != __last; ++__p, (void) ++__first)
traits_type::assign(*__p, *__first);
traits_type::assign(*__p, value_type());
__set_size(__sz + __n);
}
else
{
const basic_string __temp(__first, __last, __alloc());
append(__temp.data(), __temp.size());
}
}
return *this;
}
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str)
{
return append(__str.data(), __str.size());
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str, size_type __pos, size_type __n)
{
size_type __sz = __str.size();
if (__pos > __sz)
__throw_out_of_range();
return append(__str.data() + __pos, _VSTD::min(__n, __sz - __pos));
}
template <class _CharT, class _Traits, class _Allocator>
template <class _Tp>
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
basic_string<_CharT, _Traits, _Allocator>&
>
basic_string<_CharT, _Traits, _Allocator>::append(const _Tp & __t, size_type __pos, size_type __n)
{
__self_view __sv = __t;
size_type __sz = __sv.size();
if (__pos > __sz)
__throw_out_of_range();
return append(__sv.data() + __pos, _VSTD::min(__n, __sz - __pos));
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s)
{
_LIBCPP_ASSERT(__s != nullptr, "string::append received nullptr");
return append(__s, traits_type::length(__s));
}
// insert
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s, size_type __n)
{
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::insert received nullptr");
size_type __sz = size();
if (__pos > __sz)
__throw_out_of_range();
size_type __cap = capacity();
if (__cap - __sz >= __n)
{
if (__n)
{
value_type* __p = _VSTD::__to_address(__get_pointer());
size_type __n_move = __sz - __pos;
if (__n_move != 0)
{
if (__p + __pos <= __s && __s < __p + __sz)
__s += __n;
traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
}
traits_type::move(__p + __pos, __s, __n);
__sz += __n;
__set_size(__sz);
traits_type::assign(__p[__sz], value_type());
}
}
else
__grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n, __s);
return *this;
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n, value_type __c)
{
size_type __sz = size();
if (__pos > __sz)
__throw_out_of_range();
if (__n)
{
size_type __cap = capacity();
value_type* __p;
if (__cap - __sz >= __n)
{
__p = _VSTD::__to_address(__get_pointer());
size_type __n_move = __sz - __pos;
if (__n_move != 0)
traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
}
else
{
__grow_by(__cap, __sz + __n - __cap, __sz, __pos, 0, __n);
__p = _VSTD::__to_address(__get_long_pointer());
}
traits_type::assign(__p + __pos, __n, __c);
__sz += __n;
__set_size(__sz);
traits_type::assign(__p[__sz], value_type());
}
return *this;
}
template <class _CharT, class _Traits, class _Allocator>
template<class _InputIterator>
__enable_if_t
<
__is_exactly_cpp17_input_iterator<_InputIterator>::value,
typename basic_string<_CharT, _Traits, _Allocator>::iterator
>
basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIterator __first, _InputIterator __last)
{
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
"string::insert(iterator, range) called with an iterator not"
" referring to this string");
const basic_string __temp(__first, __last, __alloc());
return insert(__pos, __temp.data(), __temp.data() + __temp.size());
}
template <class _CharT, class _Traits, class _Allocator>
template<class _ForwardIterator>
__enable_if_t
<
__is_cpp17_forward_iterator<_ForwardIterator>::value,
typename basic_string<_CharT, _Traits, _Allocator>::iterator
>
basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last)
{
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
"string::insert(iterator, range) called with an iterator not"
" referring to this string");
size_type __ip = static_cast<size_type>(__pos - begin());
size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
if (__n)
{
if (__string_is_trivial_iterator<_ForwardIterator>::value &&
!__addr_in_range(*__first))
{
size_type __sz = size();
size_type __cap = capacity();
value_type* __p;
if (__cap - __sz >= __n)
{
__p = _VSTD::__to_address(__get_pointer());
size_type __n_move = __sz - __ip;
if (__n_move != 0)
traits_type::move(__p + __ip + __n, __p + __ip, __n_move);
}
else
{
__grow_by(__cap, __sz + __n - __cap, __sz, __ip, 0, __n);
__p = _VSTD::__to_address(__get_long_pointer());
}
__sz += __n;
__set_size(__sz);
traits_type::assign(__p[__sz], value_type());
for (__p += __ip; __first != __last; ++__p, (void) ++__first)
traits_type::assign(*__p, *__first);
}
else
{
const basic_string __temp(__first, __last, __alloc());
return insert(__pos, __temp.data(), __temp.data() + __temp.size());
}
}
return begin() + __ip;
}
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str)
{
return insert(__pos1, __str.data(), __str.size());
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str,
size_type __pos2, size_type __n)
{
size_type __str_sz = __str.size();
if (__pos2 > __str_sz)
__throw_out_of_range();
return insert(__pos1, __str.data() + __pos2, _VSTD::min(__n, __str_sz - __pos2));
}
template <class _CharT, class _Traits, class _Allocator>
template <class _Tp>
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
basic_string<_CharT, _Traits, _Allocator>&
>
basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const _Tp& __t,
size_type __pos2, size_type __n)
{
__self_view __sv = __t;
size_type __str_sz = __sv.size();
if (__pos2 > __str_sz)
__throw_out_of_range();
return insert(__pos1, __sv.data() + __pos2, _VSTD::min(__n, __str_sz - __pos2));
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s)
{
_LIBCPP_ASSERT(__s != nullptr, "string::insert received nullptr");
return insert(__pos, __s, traits_type::length(__s));
}
template <class _CharT, class _Traits, class _Allocator>
typename basic_string<_CharT, _Traits, _Allocator>::iterator
basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_type __c)
{
size_type __ip = static_cast<size_type>(__pos - begin());
size_type __sz = size();
size_type __cap = capacity();
value_type* __p;
if (__cap == __sz)
{
__grow_by(__cap, 1, __sz, __ip, 0, 1);
__p = _VSTD::__to_address(__get_long_pointer());
}
else
{
__p = _VSTD::__to_address(__get_pointer());
size_type __n_move = __sz - __ip;
if (__n_move != 0)
traits_type::move(__p + __ip + 1, __p + __ip, __n_move);
}
traits_type::assign(__p[__ip], __c);
traits_type::assign(__p[++__sz], value_type());
__set_size(__sz);
return begin() + static_cast<difference_type>(__ip);
}
template <class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::iterator
basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, size_type __n, value_type __c)
{
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
"string::insert(iterator, n, value) called with an iterator not"
" referring to this string");
difference_type __p = __pos - begin();
insert(static_cast<size_type>(__p), __n, __c);
return begin() + __p;
}
// replace
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2)
_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
{
_LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::replace received nullptr");
size_type __sz = size();
if (__pos > __sz)
__throw_out_of_range();
__n1 = _VSTD::min(__n1, __sz - __pos);
size_type __cap = capacity();
if (__cap - __sz + __n1 >= __n2)
{
value_type* __p = _VSTD::__to_address(__get_pointer());
if (__n1 != __n2)
{
size_type __n_move = __sz - __pos - __n1;
if (__n_move != 0)
{
if (__n1 > __n2)
{
traits_type::move(__p + __pos, __s, __n2);
traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
return __null_terminate_at(__p, __sz + (__n2 - __n1));
}
if (__p + __pos < __s && __s < __p + __sz)
{
if (__p + __pos + __n1 <= __s)
__s += __n2 - __n1;
else // __p + __pos < __s < __p + __pos + __n1
{
traits_type::move(__p + __pos, __s, __n1);
__pos += __n1;
__s += __n2;
__n2 -= __n1;
__n1 = 0;
}
}
traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
}
}
traits_type::move(__p + __pos, __s, __n2);
return __null_terminate_at(__p, __sz + (__n2 - __n1));
}
else
__grow_by_and_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2, __s);
return *this;
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, size_type __n2, value_type __c)
{
size_type __sz = size();
if (__pos > __sz)
__throw_out_of_range();
__n1 = _VSTD::min(__n1, __sz - __pos);
size_type __cap = capacity();
value_type* __p;
if (__cap - __sz + __n1 >= __n2)
{
__p = _VSTD::__to_address(__get_pointer());
if (__n1 != __n2)
{
size_type __n_move = __sz - __pos - __n1;
if (__n_move != 0)
traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
}
}
else
{
__grow_by(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2);
__p = _VSTD::__to_address(__get_long_pointer());
}
traits_type::assign(__p + __pos, __n2, __c);
return __null_terminate_at(__p, __sz - (__n1 - __n2));
}
template <class _CharT, class _Traits, class _Allocator>
template<class _InputIterator>
__enable_if_t
<
__is_cpp17_input_iterator<_InputIterator>::value,
basic_string<_CharT, _Traits, _Allocator>&
>
basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2,
_InputIterator __j1, _InputIterator __j2)
{
const basic_string __temp(__j1, __j2, __alloc());
return replace(__i1, __i2, __temp);
}
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str)
{
return replace(__pos1, __n1, __str.data(), __str.size());
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2)
{
size_type __str_sz = __str.size();
if (__pos2 > __str_sz)
__throw_out_of_range();
return replace(__pos1, __n1, __str.data() + __pos2, _VSTD::min(__n2, __str_sz - __pos2));
}
template <class _CharT, class _Traits, class _Allocator>
template <class _Tp>
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
basic_string<_CharT, _Traits, _Allocator>&
>
basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const _Tp& __t,
size_type __pos2, size_type __n2)
{
__self_view __sv = __t;
size_type __str_sz = __sv.size();
if (__pos2 > __str_sz)
__throw_out_of_range();
return replace(__pos1, __n1, __sv.data() + __pos2, _VSTD::min(__n2, __str_sz - __pos2));
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s)
{
_LIBCPP_ASSERT(__s != nullptr, "string::replace received nullptr");
return replace(__pos, __n1, __s, traits_type::length(__s));
}
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const basic_string& __str)
{
return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1),
__str.data(), __str.size());
}
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n)
{
return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s, __n);
}
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s)
{
return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s);
}
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c)
{
return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __n, __c);
}
// erase
// 'externally instantiated' erase() implementation, called when __n != npos.
// Does not check __pos against size()
template <class _CharT, class _Traits, class _Allocator>
void
basic_string<_CharT, _Traits, _Allocator>::__erase_external_with_move(
size_type __pos, size_type __n)
{
if (__n)
{
size_type __sz = size();
value_type* __p = _VSTD::__to_address(__get_pointer());
__n = _VSTD::min(__n, __sz - __pos);
size_type __n_move = __sz - __pos - __n;
if (__n_move != 0)
traits_type::move(__p + __pos, __p + __pos + __n, __n_move);
__null_terminate_at(__p, __sz - __n);
}
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos,
size_type __n) {
if (__pos > size())
__throw_out_of_range();
if (__n == npos) {
__erase_to_end(__pos);
} else {
__erase_external_with_move(__pos, __n);
}
return *this;
}
template <class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::iterator
basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __pos)
{
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
"string::erase(iterator) called with an iterator not"
" referring to this string");
_LIBCPP_ASSERT(__pos != end(), "string::erase(iterator) called with a non-dereferenceable iterator");
iterator __b = begin();
size_type __r = static_cast<size_type>(__pos - __b);
erase(__r, 1);
return __b + static_cast<difference_type>(__r);
}
template <class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::iterator
basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __first, const_iterator __last)
{
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__first) == this,
"string::erase(iterator, iterator) called with an iterator not"
" referring to this string");
_LIBCPP_ASSERT(__first <= __last, "string::erase(first, last) called with invalid range");
iterator __b = begin();
size_type __r = static_cast<size_type>(__first - __b);
erase(__r, static_cast<size_type>(__last - __first));
return __b + static_cast<difference_type>(__r);
}
template <class _CharT, class _Traits, class _Allocator>
inline
void
basic_string<_CharT, _Traits, _Allocator>::pop_back()
{
_LIBCPP_ASSERT(!empty(), "string::pop_back(): string is already empty");
__erase_to_end(size() - 1);
}
template <class _CharT, class _Traits, class _Allocator>
inline
void
basic_string<_CharT, _Traits, _Allocator>::clear() _NOEXCEPT
{
__invalidate_all_iterators();
if (__is_long())
{
traits_type::assign(*__get_long_pointer(), value_type());
__set_long_size(0);
}
else
{
traits_type::assign(*__get_short_pointer(), value_type());
__set_short_size(0);
}
}
template <class _CharT, class _Traits, class _Allocator>
inline
void
basic_string<_CharT, _Traits, _Allocator>::__erase_to_end(size_type __pos)
{
__null_terminate_at(_VSTD::__to_address(__get_pointer()), __pos);
}
template <class _CharT, class _Traits, class _Allocator>
void
basic_string<_CharT, _Traits, _Allocator>::resize(size_type __n, value_type __c)
{
size_type __sz = size();
if (__n > __sz)
append(__n - __sz, __c);
else
__erase_to_end(__n);
}
template <class _CharT, class _Traits, class _Allocator>
inline void
basic_string<_CharT, _Traits, _Allocator>::__resize_default_init(size_type __n)
{
size_type __sz = size();
if (__n > __sz) {
__append_default_init(__n - __sz);
} else
__erase_to_end(__n);
}
template <class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::max_size() const _NOEXCEPT
{
size_type __m = __alloc_traits::max_size(__alloc());
#ifdef _LIBCPP_BIG_ENDIAN
return (__m <= ~__long_mask ? __m : __m/2) - __alignment;
#else
return __m - __alignment;
#endif
}
template <class _CharT, class _Traits, class _Allocator>
void
basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __requested_capacity)
{
if (__requested_capacity > max_size())
__throw_length_error();
// Make sure reserve(n) never shrinks. This is technically only required in C++20
// and later (since P0966R1), however we provide consistent behavior in all Standard
// modes because this function is instantiated in the shared library.
if (__requested_capacity <= capacity())
return;
size_type __target_capacity = _VSTD::max(__requested_capacity, size());
__target_capacity = __recommend(__target_capacity);
if (__target_capacity == capacity()) return;
__shrink_or_extend(__target_capacity);
}
template <class _CharT, class _Traits, class _Allocator>
inline
void
basic_string<_CharT, _Traits, _Allocator>::shrink_to_fit() _NOEXCEPT
{
size_type __target_capacity = __recommend(size());
if (__target_capacity == capacity()) return;
__shrink_or_extend(__target_capacity);
}
template <class _CharT, class _Traits, class _Allocator>
inline
void
basic_string<_CharT, _Traits, _Allocator>::__shrink_or_extend(size_type __target_capacity)
{
size_type __cap = capacity();
size_type __sz = size();
pointer __new_data, __p;
bool __was_long, __now_long;
if (__target_capacity == __min_cap - 1)
{
__was_long = true;
__now_long = false;
__new_data = __get_short_pointer();
__p = __get_long_pointer();
}
else
{
if (__target_capacity > __cap)
__new_data = __alloc_traits::allocate(__alloc(), __target_capacity+1);
else
{
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
__new_data = __alloc_traits::allocate(__alloc(), __target_capacity+1);
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
return;
}
#else // _LIBCPP_NO_EXCEPTIONS
if (__new_data == nullptr)
return;
#endif // _LIBCPP_NO_EXCEPTIONS
}
__now_long = true;
__was_long = __is_long();
__p = __get_pointer();
}
traits_type::copy(_VSTD::__to_address(__new_data),
_VSTD::__to_address(__p), size()+1);
if (__was_long)
__alloc_traits::deallocate(__alloc(), __p, __cap+1);
if (__now_long)
{
__set_long_cap(__target_capacity+1);
__set_long_size(__sz);
__set_long_pointer(__new_data);
}
else
__set_short_size(__sz);
__invalidate_all_iterators();
}
template <class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::const_reference
basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) const _NOEXCEPT
{
_LIBCPP_ASSERT(__pos <= size(), "string index out of bounds");
return *(data() + __pos);
}
template <class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::reference
basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) _NOEXCEPT
{
_LIBCPP_ASSERT(__pos <= size(), "string index out of bounds");
return *(__get_pointer() + __pos);
}
template <class _CharT, class _Traits, class _Allocator>
typename basic_string<_CharT, _Traits, _Allocator>::const_reference
basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) const
{
if (__n >= size())
__throw_out_of_range();
return (*this)[__n];
}
template <class _CharT, class _Traits, class _Allocator>
typename basic_string<_CharT, _Traits, _Allocator>::reference
basic_string<_CharT, _Traits, _Allocator>::at(size_type __n)
{
if (__n >= size())
__throw_out_of_range();
return (*this)[__n];
}
template <class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::reference
basic_string<_CharT, _Traits, _Allocator>::front() _NOEXCEPT
{
_LIBCPP_ASSERT(!empty(), "string::front(): string is empty");
return *__get_pointer();
}
template <class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::const_reference
basic_string<_CharT, _Traits, _Allocator>::front() const _NOEXCEPT
{
_LIBCPP_ASSERT(!empty(), "string::front(): string is empty");
return *data();
}
template <class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::reference
basic_string<_CharT, _Traits, _Allocator>::back() _NOEXCEPT
{
_LIBCPP_ASSERT(!empty(), "string::back(): string is empty");
return *(__get_pointer() + size() - 1);
}
template <class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::const_reference
basic_string<_CharT, _Traits, _Allocator>::back() const _NOEXCEPT
{
_LIBCPP_ASSERT(!empty(), "string::back(): string is empty");
return *(data() + size() - 1);
}
template <class _CharT, class _Traits, class _Allocator>
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::copy(value_type* __s, size_type __n, size_type __pos) const
{
size_type __sz = size();
if (__pos > __sz)
__throw_out_of_range();
size_type __rlen = _VSTD::min(__n, __sz - __pos);
traits_type::copy(__s, data() + __pos, __rlen);
return __rlen;
}
template <class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>
basic_string<_CharT, _Traits, _Allocator>::substr(size_type __pos, size_type __n) const
{
return basic_string(*this, __pos, __n, __alloc());
}
template <class _CharT, class _Traits, class _Allocator>
inline
void
basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str)
#if _LIBCPP_STD_VER >= 14
_NOEXCEPT
#else
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
__is_nothrow_swappable<allocator_type>::value)
#endif
{
#if _LIBCPP_DEBUG_LEVEL == 2
if (!__libcpp_is_constant_evaluated()) {
if (!__is_long())
__get_db()->__invalidate_all(this);
if (!__str.__is_long())
__get_db()->__invalidate_all(&__str);
__get_db()->swap(this, &__str);
}
#endif
_LIBCPP_ASSERT(
__alloc_traits::propagate_on_container_swap::value ||
__alloc_traits::is_always_equal::value ||
__alloc() == __str.__alloc(), "swapping non-equal allocators");
_VSTD::swap(__r_.first(), __str.__r_.first());
_VSTD::__swap_allocator(__alloc(), __str.__alloc());
}
// find
template <class _Traits>
struct _LIBCPP_HIDDEN __traits_eq
{
typedef typename _Traits::char_type char_type;
_LIBCPP_INLINE_VISIBILITY
bool operator()(const char_type& __x, const char_type& __y) _NOEXCEPT
{return _Traits::eq(__x, __y);}
};
template<class _CharT, class _Traits, class _Allocator>
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
size_type __pos,
size_type __n) const _NOEXCEPT
{
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find(): received nullptr");
return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n);
}
template<class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find(const basic_string& __str,
size_type __pos) const _NOEXCEPT
{
return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __str.data(), __pos, __str.size());
}
template<class _CharT, class _Traits, class _Allocator>
template <class _Tp>
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
typename basic_string<_CharT, _Traits, _Allocator>::size_type
>
basic_string<_CharT, _Traits, _Allocator>::find(const _Tp &__t,
size_type __pos) const _NOEXCEPT
{
__self_view __sv = __t;
return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __sv.data(), __pos, __sv.size());
}
template<class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
size_type __pos) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s != nullptr, "string::find(): received nullptr");
return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s));
}
template<class _CharT, class _Traits, class _Allocator>
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find(value_type __c,
size_type __pos) const _NOEXCEPT
{
return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos);
}
// rfind
template<class _CharT, class _Traits, class _Allocator>
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
size_type __pos,
size_type __n) const _NOEXCEPT
{
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::rfind(): received nullptr");
return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n);
}
template<class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::rfind(const basic_string& __str,
size_type __pos) const _NOEXCEPT
{
return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __str.data(), __pos, __str.size());
}
template<class _CharT, class _Traits, class _Allocator>
template <class _Tp>
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
typename basic_string<_CharT, _Traits, _Allocator>::size_type
>
basic_string<_CharT, _Traits, _Allocator>::rfind(const _Tp& __t,
size_type __pos) const _NOEXCEPT
{
__self_view __sv = __t;
return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __sv.data(), __pos, __sv.size());
}
template<class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
size_type __pos) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s != nullptr, "string::rfind(): received nullptr");
return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s));
}
template<class _CharT, class _Traits, class _Allocator>
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::rfind(value_type __c,
size_type __pos) const _NOEXCEPT
{
return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos);
}
// find_first_of
template<class _CharT, class _Traits, class _Allocator>
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
size_type __pos,
size_type __n) const _NOEXCEPT
{
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_of(): received nullptr");
return __str_find_first_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n);
}
template<class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_first_of(const basic_string& __str,
size_type __pos) const _NOEXCEPT
{
return __str_find_first_of<value_type, size_type, traits_type, npos>
(data(), size(), __str.data(), __pos, __str.size());
}
template<class _CharT, class _Traits, class _Allocator>
template <class _Tp>
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
typename basic_string<_CharT, _Traits, _Allocator>::size_type
>
basic_string<_CharT, _Traits, _Allocator>::find_first_of(const _Tp& __t,
size_type __pos) const _NOEXCEPT
{
__self_view __sv = __t;
return __str_find_first_of<value_type, size_type, traits_type, npos>
(data(), size(), __sv.data(), __pos, __sv.size());
}
template<class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
size_type __pos) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s != nullptr, "string::find_first_of(): received nullptr");
return __str_find_first_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s));
}
template<class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_first_of(value_type __c,
size_type __pos) const _NOEXCEPT
{
return find(__c, __pos);
}
// find_last_of
template<class _CharT, class _Traits, class _Allocator>
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
size_type __pos,
size_type __n) const _NOEXCEPT
{
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_of(): received nullptr");
return __str_find_last_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n);
}
template<class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_last_of(const basic_string& __str,
size_type __pos) const _NOEXCEPT
{
return __str_find_last_of<value_type, size_type, traits_type, npos>
(data(), size(), __str.data(), __pos, __str.size());
}
template<class _CharT, class _Traits, class _Allocator>
template <class _Tp>
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
typename basic_string<_CharT, _Traits, _Allocator>::size_type
>
basic_string<_CharT, _Traits, _Allocator>::find_last_of(const _Tp& __t,
size_type __pos) const _NOEXCEPT
{
__self_view __sv = __t;
return __str_find_last_of<value_type, size_type, traits_type, npos>
(data(), size(), __sv.data(), __pos, __sv.size());
}
template<class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
size_type __pos) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s != nullptr, "string::find_last_of(): received nullptr");
return __str_find_last_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s));
}
template<class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_last_of(value_type __c,
size_type __pos) const _NOEXCEPT
{
return rfind(__c, __pos);
}
// find_first_not_of
template<class _CharT, class _Traits, class _Allocator>
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
size_type __pos,
size_type __n) const _NOEXCEPT
{
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_not_of(): received nullptr");
return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n);
}
template<class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const basic_string& __str,
size_type __pos) const _NOEXCEPT
{
return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __str.data(), __pos, __str.size());
}
template<class _CharT, class _Traits, class _Allocator>
template <class _Tp>
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
typename basic_string<_CharT, _Traits, _Allocator>::size_type
>
basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const _Tp& __t,
size_type __pos) const _NOEXCEPT
{
__self_view __sv = __t;
return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __sv.data(), __pos, __sv.size());
}
template<class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
size_type __pos) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s != nullptr, "string::find_first_not_of(): received nullptr");
return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s));
}
template<class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(value_type __c,
size_type __pos) const _NOEXCEPT
{
return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos);
}
// find_last_not_of
template<class _CharT, class _Traits, class _Allocator>
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
size_type __pos,
size_type __n) const _NOEXCEPT
{
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_not_of(): received nullptr");
return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n);
}
template<class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const basic_string& __str,
size_type __pos) const _NOEXCEPT
{
return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __str.data(), __pos, __str.size());
}
template<class _CharT, class _Traits, class _Allocator>
template <class _Tp>
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
typename basic_string<_CharT, _Traits, _Allocator>::size_type
>
basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const _Tp& __t,
size_type __pos) const _NOEXCEPT
{
__self_view __sv = __t;
return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __sv.data(), __pos, __sv.size());
}
template<class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
size_type __pos) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s != nullptr, "string::find_last_not_of(): received nullptr");
return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s));
}
template<class _CharT, class _Traits, class _Allocator>
inline
typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(value_type __c,
size_type __pos) const _NOEXCEPT
{
return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos);
}
// compare
template <class _CharT, class _Traits, class _Allocator>
template <class _Tp>
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
int
>
basic_string<_CharT, _Traits, _Allocator>::compare(const _Tp& __t) const _NOEXCEPT
{
__self_view __sv = __t;
size_t __lhs_sz = size();
size_t __rhs_sz = __sv.size();
int __result = traits_type::compare(data(), __sv.data(),
_VSTD::min(__lhs_sz, __rhs_sz));
if (__result != 0)
return __result;
if (__lhs_sz < __rhs_sz)
return -1;
if (__lhs_sz > __rhs_sz)
return 1;
return 0;
}
template <class _CharT, class _Traits, class _Allocator>
inline
int
basic_string<_CharT, _Traits, _Allocator>::compare(const basic_string& __str) const _NOEXCEPT
{
return compare(__self_view(__str));
}
template <class _CharT, class _Traits, class _Allocator>
int
basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
size_type __n1,
const value_type* __s,
size_type __n2) const
{
_LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::compare(): received nullptr");
size_type __sz = size();
if (__pos1 > __sz || __n2 == npos)
__throw_out_of_range();
size_type __rlen = _VSTD::min(__n1, __sz - __pos1);
int __r = traits_type::compare(data() + __pos1, __s, _VSTD::min(__rlen, __n2));
if (__r == 0)
{
if (__rlen < __n2)
__r = -1;
else if (__rlen > __n2)
__r = 1;
}
return __r;
}
template <class _CharT, class _Traits, class _Allocator>
template <class _Tp>
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
int
>
basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
size_type __n1,
const _Tp& __t) const
{
__self_view __sv = __t;
return compare(__pos1, __n1, __sv.data(), __sv.size());
}
template <class _CharT, class _Traits, class _Allocator>
inline
int
basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
size_type __n1,
const basic_string& __str) const
{
return compare(__pos1, __n1, __str.data(), __str.size());
}
template <class _CharT, class _Traits, class _Allocator>
template <class _Tp>
__enable_if_t
<
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
&& !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
int
>
basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
size_type __n1,
const _Tp& __t,
size_type __pos2,
size_type __n2) const
{
__self_view __sv = __t;
return __self_view(*this).substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
}
template <class _CharT, class _Traits, class _Allocator>
int
basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
size_type __n1,
const basic_string& __str,
size_type __pos2,
size_type __n2) const
{
return compare(__pos1, __n1, __self_view(__str), __pos2, __n2);
}
template <class _CharT, class _Traits, class _Allocator>
int
basic_string<_CharT, _Traits, _Allocator>::compare(const value_type* __s) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr");
return compare(0, npos, __s, traits_type::length(__s));
}
template <class _CharT, class _Traits, class _Allocator>
int
basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
size_type __n1,
const value_type* __s) const
{
_LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr");
return compare(__pos1, __n1, __s, traits_type::length(__s));
}
// __invariants
template<class _CharT, class _Traits, class _Allocator>
inline
bool
basic_string<_CharT, _Traits, _Allocator>::__invariants() const
{
if (size() > capacity())
return false;
if (capacity() < __min_cap - 1)
return false;
if (data() == nullptr)
return false;
if (data()[size()] != value_type())
return false;
return true;
}
// __clear_and_shrink
template<class _CharT, class _Traits, class _Allocator>
inline
void
basic_string<_CharT, _Traits, _Allocator>::__clear_and_shrink() _NOEXCEPT
{
clear();
if(__is_long())
{
__alloc_traits::deallocate(__alloc(), __get_long_pointer(), capacity() + 1);
__set_long_cap(0);
__set_short_size(0);
traits_type::assign(*__get_short_pointer(), value_type());
}
}
// operator==
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{
size_t __lhs_sz = __lhs.size();
return __lhs_sz == __rhs.size() && _Traits::compare(__lhs.data(),
__rhs.data(),
__lhs_sz) == 0;
}
template<class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs,
const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPT
{
size_t __lhs_sz = __lhs.size();
if (__lhs_sz != __rhs.size())
return false;
const char* __lp = __lhs.data();
const char* __rp = __rhs.data();
if (__lhs.__is_long())
return char_traits<char>::compare(__lp, __rp, __lhs_sz) == 0;
for (; __lhs_sz != 0; --__lhs_sz, ++__lp, ++__rp)
if (*__lp != *__rp)
return false;
return true;
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator==(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{
typedef basic_string<_CharT, _Traits, _Allocator> _String;
_LIBCPP_ASSERT(__lhs != nullptr, "operator==(char*, basic_string): received nullptr");
size_t __lhs_len = _Traits::length(__lhs);
if (__lhs_len != __rhs.size()) return false;
return __rhs.compare(0, _String::npos, __lhs, __lhs_len) == 0;
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
const _CharT* __rhs) _NOEXCEPT
{
typedef basic_string<_CharT, _Traits, _Allocator> _String;
_LIBCPP_ASSERT(__rhs != nullptr, "operator==(basic_string, char*): received nullptr");
size_t __rhs_len = _Traits::length(__rhs);
if (__rhs_len != __lhs.size()) return false;
return __lhs.compare(0, _String::npos, __rhs, __rhs_len) == 0;
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{
return !(__lhs == __rhs);
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator!=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{
return !(__lhs == __rhs);
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator!=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const _CharT* __rhs) _NOEXCEPT
{
return !(__lhs == __rhs);
}
// operator<
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{
return __lhs.compare(__rhs) < 0;
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const _CharT* __rhs) _NOEXCEPT
{
return __lhs.compare(__rhs) < 0;
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator< (const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{
return __rhs.compare(__lhs) > 0;
}
// operator>
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{
return __rhs < __lhs;
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const _CharT* __rhs) _NOEXCEPT
{
return __rhs < __lhs;
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator> (const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{
return __rhs < __lhs;
}
// operator<=
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{
return !(__rhs < __lhs);
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const _CharT* __rhs) _NOEXCEPT
{
return !(__rhs < __lhs);
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{
return !(__rhs < __lhs);
}
// operator>=
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{
return !(__lhs < __rhs);
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const _CharT* __rhs) _NOEXCEPT
{
return !(__lhs < __rhs);
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator>=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{
return !(__lhs < __rhs);
}
// operator +
template<class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs)
{
basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator());
typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size();
typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size();
__r.__init(__lhs.data(), __lhs_sz, __lhs_sz + __rhs_sz);
__r.append(__rhs.data(), __rhs_sz);
return __r;
}
template<class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>
operator+(const _CharT* __lhs , const basic_string<_CharT,_Traits,_Allocator>& __rhs)
{
basic_string<_CharT, _Traits, _Allocator> __r(__rhs.get_allocator());
typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = _Traits::length(__lhs);
typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size();
__r.__init(__lhs, __lhs_sz, __lhs_sz + __rhs_sz);
__r.append(__rhs.data(), __rhs_sz);
return __r;
}
template<class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>
operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Allocator>& __rhs)
{
basic_string<_CharT, _Traits, _Allocator> __r(__rhs.get_allocator());
typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size();
__r.__init(&__lhs, 1, 1 + __rhs_sz);
__r.append(__rhs.data(), __rhs_sz);
return __r;
}
template<class _CharT, class _Traits, class _Allocator>
inline
basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs)
{
basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator());
typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size();
typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = _Traits::length(__rhs);
__r.__init(__lhs.data(), __lhs_sz, __lhs_sz + __rhs_sz);
__r.append(__rhs, __rhs_sz);
return __r;
}
template<class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, _CharT __rhs)
{
basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator());
typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size();
__r.__init(__lhs.data(), __lhs_sz, __lhs_sz + 1);
__r.push_back(__rhs);
return __r;
}
#ifndef _LIBCPP_CXX03_LANG
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
basic_string<_CharT, _Traits, _Allocator>
operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs)
{
return _VSTD::move(__lhs.append(__rhs));
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
{
return _VSTD::move(__rhs.insert(0, __lhs));
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
basic_string<_CharT, _Traits, _Allocator>
operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
{
return _VSTD::move(__lhs.append(__rhs));
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
basic_string<_CharT, _Traits, _Allocator>
operator+(const _CharT* __lhs , basic_string<_CharT,_Traits,_Allocator>&& __rhs)
{
return _VSTD::move(__rhs.insert(0, __lhs));
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
basic_string<_CharT, _Traits, _Allocator>
operator+(_CharT __lhs, basic_string<_CharT,_Traits,_Allocator>&& __rhs)
{
__rhs.insert(__rhs.begin(), __lhs);
return _VSTD::move(__rhs);
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
basic_string<_CharT, _Traits, _Allocator>
operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const _CharT* __rhs)
{
return _VSTD::move(__lhs.append(__rhs));
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
basic_string<_CharT, _Traits, _Allocator>
operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, _CharT __rhs)
{
__lhs.push_back(__rhs);
return _VSTD::move(__lhs);
}
#endif // _LIBCPP_CXX03_LANG
// swap
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
void
swap(basic_string<_CharT, _Traits, _Allocator>& __lhs,
basic_string<_CharT, _Traits, _Allocator>& __rhs)
_NOEXCEPT_(_NOEXCEPT_(__lhs.swap(__rhs)))
{
__lhs.swap(__rhs);
}
_LIBCPP_FUNC_VIS int stoi (const string& __str, size_t* __idx = nullptr, int __base = 10);
_LIBCPP_FUNC_VIS long stol (const string& __str, size_t* __idx = nullptr, int __base = 10);
_LIBCPP_FUNC_VIS unsigned long stoul (const string& __str, size_t* __idx = nullptr, int __base = 10);
_LIBCPP_FUNC_VIS long long stoll (const string& __str, size_t* __idx = nullptr, int __base = 10);
_LIBCPP_FUNC_VIS unsigned long long stoull(const string& __str, size_t* __idx = nullptr, int __base = 10);
_LIBCPP_FUNC_VIS float stof (const string& __str, size_t* __idx = nullptr);
_LIBCPP_FUNC_VIS double stod (const string& __str, size_t* __idx = nullptr);
_LIBCPP_FUNC_VIS long double stold(const string& __str, size_t* __idx = nullptr);
_LIBCPP_FUNC_VIS string to_string(int __val);
_LIBCPP_FUNC_VIS string to_string(unsigned __val);
_LIBCPP_FUNC_VIS string to_string(long __val);
_LIBCPP_FUNC_VIS string to_string(unsigned long __val);
_LIBCPP_FUNC_VIS string to_string(long long __val);
_LIBCPP_FUNC_VIS string to_string(unsigned long long __val);
_LIBCPP_FUNC_VIS string to_string(float __val);
_LIBCPP_FUNC_VIS string to_string(double __val);
_LIBCPP_FUNC_VIS string to_string(long double __val);
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_FUNC_VIS int stoi (const wstring& __str, size_t* __idx = nullptr, int __base = 10);
_LIBCPP_FUNC_VIS long stol (const wstring& __str, size_t* __idx = nullptr, int __base = 10);
_LIBCPP_FUNC_VIS unsigned long stoul (const wstring& __str, size_t* __idx = nullptr, int __base = 10);
_LIBCPP_FUNC_VIS long long stoll (const wstring& __str, size_t* __idx = nullptr, int __base = 10);
_LIBCPP_FUNC_VIS unsigned long long stoull(const wstring& __str, size_t* __idx = nullptr, int __base = 10);
_LIBCPP_FUNC_VIS float stof (const wstring& __str, size_t* __idx = nullptr);
_LIBCPP_FUNC_VIS double stod (const wstring& __str, size_t* __idx = nullptr);
_LIBCPP_FUNC_VIS long double stold(const wstring& __str, size_t* __idx = nullptr);
_LIBCPP_FUNC_VIS wstring to_wstring(int __val);
_LIBCPP_FUNC_VIS wstring to_wstring(unsigned __val);
_LIBCPP_FUNC_VIS wstring to_wstring(long __val);
_LIBCPP_FUNC_VIS wstring to_wstring(unsigned long __val);
_LIBCPP_FUNC_VIS wstring to_wstring(long long __val);
_LIBCPP_FUNC_VIS wstring to_wstring(unsigned long long __val);
_LIBCPP_FUNC_VIS wstring to_wstring(float __val);
_LIBCPP_FUNC_VIS wstring to_wstring(double __val);
_LIBCPP_FUNC_VIS wstring to_wstring(long double __val);
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
template<class _CharT, class _Traits, class _Allocator>
_LIBCPP_TEMPLATE_DATA_VIS
const typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::npos;
template <class _CharT, class _Allocator>
struct _LIBCPP_TEMPLATE_VIS
hash<basic_string<_CharT, char_traits<_CharT>, _Allocator> >
: public unary_function<
basic_string<_CharT, char_traits<_CharT>, _Allocator>, size_t>
{
size_t
operator()(const basic_string<_CharT, char_traits<_CharT>, _Allocator>& __val) const _NOEXCEPT
{ return __do_string_hash(__val.data(), __val.data() + __val.size()); }
};
template<class _CharT, class _Traits, class _Allocator>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os,
const basic_string<_CharT, _Traits, _Allocator>& __str);
template<class _CharT, class _Traits, class _Allocator>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Allocator>& __str);
template<class _CharT, class _Traits, class _Allocator>
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm);
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Allocator>& __str);
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>&& __is,
basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm);
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>&& __is,
basic_string<_CharT, _Traits, _Allocator>& __str);
#if _LIBCPP_STD_VER > 17
template <class _CharT, class _Traits, class _Allocator, class _Up>
inline _LIBCPP_INLINE_VISIBILITY
typename basic_string<_CharT, _Traits, _Allocator>::size_type
erase(basic_string<_CharT, _Traits, _Allocator>& __str, const _Up& __v) {
auto __old_size = __str.size();
__str.erase(_VSTD::remove(__str.begin(), __str.end(), __v), __str.end());
return __old_size - __str.size();
}
template <class _CharT, class _Traits, class _Allocator, class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY
typename basic_string<_CharT, _Traits, _Allocator>::size_type
erase_if(basic_string<_CharT, _Traits, _Allocator>& __str,
_Predicate __pred) {
auto __old_size = __str.size();
__str.erase(_VSTD::remove_if(__str.begin(), __str.end(), __pred),
__str.end());
return __old_size - __str.size();
}
#endif
#if _LIBCPP_DEBUG_LEVEL == 2
template<class _CharT, class _Traits, class _Allocator>
bool
basic_string<_CharT, _Traits, _Allocator>::__dereferenceable(const const_iterator* __i) const
{
return data() <= _VSTD::__to_address(__i->base()) &&
_VSTD::__to_address(__i->base()) < data() + size();
}
template<class _CharT, class _Traits, class _Allocator>
bool
basic_string<_CharT, _Traits, _Allocator>::__decrementable(const const_iterator* __i) const
{
return data() < _VSTD::__to_address(__i->base()) &&
_VSTD::__to_address(__i->base()) <= data() + size();
}
template<class _CharT, class _Traits, class _Allocator>
bool
basic_string<_CharT, _Traits, _Allocator>::__addable(const const_iterator* __i, ptrdiff_t __n) const
{
const value_type* __p = _VSTD::__to_address(__i->base()) + __n;
return data() <= __p && __p <= data() + size();
}
template<class _CharT, class _Traits, class _Allocator>
bool
basic_string<_CharT, _Traits, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const
{
const value_type* __p = _VSTD::__to_address(__i->base()) + __n;
return data() <= __p && __p < data() + size();
}
#endif // _LIBCPP_DEBUG_LEVEL == 2
#if _LIBCPP_STD_VER > 11
// Literal suffixes for basic_string [basic.string.literals]
inline namespace literals
{
inline namespace string_literals
{
inline _LIBCPP_INLINE_VISIBILITY
basic_string<char> operator "" s( const char *__str, size_t __len )
{
return basic_string<char> (__str, __len);
}
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
inline _LIBCPP_INLINE_VISIBILITY
basic_string<wchar_t> operator "" s( const wchar_t *__str, size_t __len )
{
return basic_string<wchar_t> (__str, __len);
}
#endif
#ifndef _LIBCPP_HAS_NO_CHAR8_T
inline _LIBCPP_INLINE_VISIBILITY
basic_string<char8_t> operator "" s(const char8_t *__str, size_t __len) _NOEXCEPT
{
return basic_string<char8_t> (__str, __len);
}
#endif
inline _LIBCPP_INLINE_VISIBILITY
basic_string<char16_t> operator "" s( const char16_t *__str, size_t __len )
{
return basic_string<char16_t> (__str, __len);
}
inline _LIBCPP_INLINE_VISIBILITY
basic_string<char32_t> operator "" s( const char32_t *__str, size_t __len )
{
return basic_string<char32_t> (__str, __len);
}
} // namespace string_literals
} // namespace literals
#endif
_LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS
#endif // _LIBCPP_STRING
diff --git a/contrib/llvm-project/libcxx/include/string_view b/contrib/llvm-project/libcxx/include/string_view
index 992e88ea3c00..5d0a790dd13d 100644
--- a/contrib/llvm-project/libcxx/include/string_view
+++ b/contrib/llvm-project/libcxx/include/string_view
@@ -1,957 +1,957 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_STRING_VIEW
#define _LIBCPP_STRING_VIEW
/*
string_view synopsis
namespace std {
// 7.2, Class template basic_string_view
template<class charT, class traits = char_traits<charT>>
class basic_string_view;
template<class charT, class traits>
inline constexpr bool ranges::enable_view<basic_string_view<charT, traits>> = true;
template<class charT, class traits>
inline constexpr bool ranges::enable_borrowed_range<basic_string_view<charT, traits>> = true; // C++20
// 7.9, basic_string_view non-member comparison functions
template<class charT, class traits>
constexpr bool operator==(basic_string_view<charT, traits> x,
basic_string_view<charT, traits> y) noexcept;
template<class charT, class traits>
constexpr bool operator!=(basic_string_view<charT, traits> x,
basic_string_view<charT, traits> y) noexcept;
template<class charT, class traits>
constexpr bool operator< (basic_string_view<charT, traits> x,
basic_string_view<charT, traits> y) noexcept;
template<class charT, class traits>
constexpr bool operator> (basic_string_view<charT, traits> x,
basic_string_view<charT, traits> y) noexcept;
template<class charT, class traits>
constexpr bool operator<=(basic_string_view<charT, traits> x,
basic_string_view<charT, traits> y) noexcept;
template<class charT, class traits>
constexpr bool operator>=(basic_string_view<charT, traits> x,
basic_string_view<charT, traits> y) noexcept;
// see below, sufficient additional overloads of comparison functions
// 7.10, Inserters and extractors
template<class charT, class traits>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
basic_string_view<charT, traits> str);
// basic_string_view typedef names
typedef basic_string_view<char> string_view;
typedef basic_string_view<char8_t> u8string_view; // C++20
typedef basic_string_view<char16_t> u16string_view;
typedef basic_string_view<char32_t> u32string_view;
typedef basic_string_view<wchar_t> wstring_view;
template<class charT, class traits = char_traits<charT>>
class basic_string_view {
public:
// types
typedef traits traits_type;
typedef charT value_type;
typedef charT* pointer;
typedef const charT* const_pointer;
typedef charT& reference;
typedef const charT& const_reference;
typedef implementation-defined const_iterator;
typedef const_iterator iterator;
typedef reverse_iterator<const_iterator> const_reverse_iterator;
typedef const_reverse_iterator reverse_iterator;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
static constexpr size_type npos = size_type(-1);
// 7.3, basic_string_view constructors and assignment operators
constexpr basic_string_view() noexcept;
constexpr basic_string_view(const basic_string_view&) noexcept = default;
basic_string_view& operator=(const basic_string_view&) noexcept = default;
template<class Allocator>
constexpr basic_string_view(const charT* str);
basic_string_view(nullptr_t) = delete; // C++2b
constexpr basic_string_view(const charT* str, size_type len);
template <class It, class End>
constexpr basic_string_view(It begin, End end); // C++20
template <class Range>
constexpr basic_string_view(Range&& r); // C++23
// 7.4, basic_string_view iterator support
constexpr const_iterator begin() const noexcept;
constexpr const_iterator end() const noexcept;
constexpr const_iterator cbegin() const noexcept;
constexpr const_iterator cend() const noexcept;
const_reverse_iterator rbegin() const noexcept;
const_reverse_iterator rend() const noexcept;
const_reverse_iterator crbegin() const noexcept;
const_reverse_iterator crend() const noexcept;
// 7.5, basic_string_view capacity
constexpr size_type size() const noexcept;
constexpr size_type length() const noexcept;
constexpr size_type max_size() const noexcept;
constexpr bool empty() const noexcept;
// 7.6, basic_string_view element access
constexpr const_reference operator[](size_type pos) const;
constexpr const_reference at(size_type pos) const;
constexpr const_reference front() const;
constexpr const_reference back() const;
constexpr const_pointer data() const noexcept;
// 7.7, basic_string_view modifiers
constexpr void remove_prefix(size_type n);
constexpr void remove_suffix(size_type n);
constexpr void swap(basic_string_view& s) noexcept;
size_type copy(charT* s, size_type n, size_type pos = 0) const; // constexpr in C++20
constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
constexpr int compare(basic_string_view s) const noexcept;
constexpr int compare(size_type pos1, size_type n1, basic_string_view s) const;
constexpr int compare(size_type pos1, size_type n1,
basic_string_view s, size_type pos2, size_type n2) const;
constexpr int compare(const charT* s) const;
constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
constexpr int compare(size_type pos1, size_type n1,
const charT* s, size_type n2) const;
constexpr size_type find(basic_string_view s, size_type pos = 0) const noexcept;
constexpr size_type find(charT c, size_type pos = 0) const noexcept;
constexpr size_type find(const charT* s, size_type pos, size_type n) const noexcept; // noexcept as an extension
constexpr size_type find(const charT* s, size_type pos = 0) const noexcept; // noexcept as an extension
constexpr size_type rfind(basic_string_view s, size_type pos = npos) const noexcept;
constexpr size_type rfind(charT c, size_type pos = npos) const noexcept;
constexpr size_type rfind(const charT* s, size_type pos, size_type n) const noexcept; // noexcept as an extension
constexpr size_type rfind(const charT* s, size_type pos = npos) const noexcept; // noexcept as an extension
constexpr size_type find_first_of(basic_string_view s, size_type pos = 0) const noexcept;
constexpr size_type find_first_of(charT c, size_type pos = 0) const noexcept;
constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const noexcept; // noexcept as an extension
constexpr size_type find_first_of(const charT* s, size_type pos = 0) const noexcept; // noexcept as an extension
constexpr size_type find_last_of(basic_string_view s, size_type pos = npos) const noexcept;
constexpr size_type find_last_of(charT c, size_type pos = npos) const noexcept;
constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const noexcept; // noexcept as an extension
constexpr size_type find_last_of(const charT* s, size_type pos = npos) const noexcept; // noexcept as an extension
constexpr size_type find_first_not_of(basic_string_view s, size_type pos = 0) const noexcept;
constexpr size_type find_first_not_of(charT c, size_type pos = 0) const noexcept;
constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const noexcept; // noexcept as an extension
constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const noexcept; // noexcept as an extension
constexpr size_type find_last_not_of(basic_string_view s, size_type pos = npos) const noexcept;
constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept;
constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const noexcept; // noexcept as an extension
constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const noexcept; // noexcept as an extension
constexpr bool starts_with(basic_string_view s) const noexcept; // C++20
constexpr bool starts_with(charT c) const noexcept; // C++20
constexpr bool starts_with(const charT* s) const; // C++20
constexpr bool ends_with(basic_string_view s) const noexcept; // C++20
constexpr bool ends_with(charT c) const noexcept; // C++20
constexpr bool ends_with(const charT* s) const; // C++20
constexpr bool contains(basic_string_view s) const noexcept; // C++2b
constexpr bool contains(charT c) const noexcept; // C++2b
constexpr bool contains(const charT* s) const; // C++2b
private:
const_pointer data_; // exposition only
size_type size_; // exposition only
};
// basic_string_view deduction guides
template<class It, class End>
basic_string_view(It, End) -> basic_string_view<iter_value_t<It>>; // C++20
template<class Range>
basic_string_view(Range&&) -> basic_string_view<ranges::range_value_t<Range>>; // C++23
// 7.11, Hash support
template <class T> struct hash;
template <> struct hash<string_view>;
template <> struct hash<u8string_view>; // C++20
template <> struct hash<u16string_view>;
template <> struct hash<u32string_view>;
template <> struct hash<wstring_view>;
constexpr basic_string_view<char> operator "" sv( const char *str, size_t len ) noexcept;
constexpr basic_string_view<wchar_t> operator "" sv( const wchar_t *str, size_t len ) noexcept;
constexpr basic_string_view<char8_t> operator "" sv( const char8_t *str, size_t len ) noexcept; // C++20
constexpr basic_string_view<char16_t> operator "" sv( const char16_t *str, size_t len ) noexcept;
constexpr basic_string_view<char32_t> operator "" sv( const char32_t *str, size_t len ) noexcept;
} // namespace std
*/
#include <__config>
#include <__debug>
#include <__ranges/concepts.h>
#include <__ranges/data.h>
#include <__ranges/enable_borrowed_range.h>
#include <__ranges/enable_view.h>
#include <__ranges/size.h>
#include <__string>
#include <algorithm>
#include <compare>
#include <iosfwd>
#include <iterator>
#include <limits>
#include <stdexcept>
#include <type_traits>
#include <version>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_PUSH_MACROS
#include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_TEMPLATE_VIS basic_string_view;
typedef basic_string_view<char> string_view;
#ifndef _LIBCPP_HAS_NO_CHAR8_T
typedef basic_string_view<char8_t> u8string_view;
#endif
typedef basic_string_view<char16_t> u16string_view;
typedef basic_string_view<char32_t> u32string_view;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
typedef basic_string_view<wchar_t> wstring_view;
#endif
template<class _CharT, class _Traits>
class
_LIBCPP_PREFERRED_NAME(string_view)
#ifndef _LIBCPP_HAS_NO_CHAR8_T
_LIBCPP_PREFERRED_NAME(u8string_view)
#endif
_LIBCPP_PREFERRED_NAME(u16string_view)
_LIBCPP_PREFERRED_NAME(u32string_view)
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wstring_view))
basic_string_view {
public:
// types
typedef _Traits traits_type;
typedef _CharT value_type;
typedef _CharT* pointer;
typedef const _CharT* const_pointer;
typedef _CharT& reference;
typedef const _CharT& const_reference;
typedef const_pointer const_iterator; // See [string.view.iterators]
typedef const_iterator iterator;
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef const_reverse_iterator reverse_iterator;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
static _LIBCPP_CONSTEXPR const size_type npos = -1; // size_type(-1);
static_assert((!is_array<value_type>::value), "Character type of basic_string_view must not be an array");
static_assert(( is_standard_layout<value_type>::value), "Character type of basic_string_view must be standard-layout");
static_assert(( is_trivial<value_type>::value), "Character type of basic_string_view must be trivial");
static_assert((is_same<_CharT, typename traits_type::char_type>::value),
"traits_type::char_type must be the same type as CharT");
// [string.view.cons], construct/copy
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
basic_string_view() _NOEXCEPT : __data (nullptr), __size(0) {}
_LIBCPP_INLINE_VISIBILITY
basic_string_view(const basic_string_view&) _NOEXCEPT = default;
_LIBCPP_INLINE_VISIBILITY
basic_string_view& operator=(const basic_string_view&) _NOEXCEPT = default;
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
basic_string_view(const _CharT* __s, size_type __len) _NOEXCEPT
: __data(__s), __size(__len)
{
#if _LIBCPP_STD_VER > 11
_LIBCPP_ASSERT(__len == 0 || __s != nullptr, "string_view::string_view(_CharT *, size_t): received nullptr");
#endif
}
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <contiguous_iterator _It, sized_sentinel_for<_It> _End>
requires (is_same_v<iter_value_t<_It>, _CharT> && !is_convertible_v<_End, size_type>)
constexpr _LIBCPP_HIDE_FROM_ABI basic_string_view(_It __begin, _End __end)
: __data(_VSTD::to_address(__begin)), __size(__end - __begin)
{
_LIBCPP_ASSERT((__end - __begin) >= 0, "std::string_view::string_view(iterator, sentinel) received invalid range");
}
#endif
#if _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _Range>
requires (
!is_same_v<remove_cvref_t<_Range>, basic_string_view> &&
ranges::contiguous_range<_Range> &&
ranges::sized_range<_Range> &&
is_same_v<ranges::range_value_t<_Range>, _CharT> &&
!is_convertible_v<_Range, const _CharT*> &&
(!requires(remove_cvref_t<_Range>& d) {
d.operator _VSTD::basic_string_view<_CharT, _Traits>();
}) &&
(!requires {
typename remove_reference_t<_Range>::traits_type;
} || is_same_v<typename remove_reference_t<_Range>::traits_type, _Traits>)
)
constexpr _LIBCPP_HIDE_FROM_ABI
basic_string_view(_Range&& __r) : __data(ranges::data(__r)), __size(ranges::size(__r)) {}
#endif
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
basic_string_view(const _CharT* __s)
: __data(__s), __size(_VSTD::__char_traits_length_checked<_Traits>(__s)) {}
#if _LIBCPP_STD_VER > 20
basic_string_view(nullptr_t) = delete;
#endif
// [string.view.iterators], iterators
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
const_iterator begin() const _NOEXCEPT { return cbegin(); }
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
const_iterator end() const _NOEXCEPT { return cend(); }
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
const_iterator cbegin() const _NOEXCEPT { return __data; }
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
const_iterator cend() const _NOEXCEPT { return __data + __size; }
_LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY
const_reverse_iterator rbegin() const _NOEXCEPT { return const_reverse_iterator(cend()); }
_LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY
const_reverse_iterator rend() const _NOEXCEPT { return const_reverse_iterator(cbegin()); }
_LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY
const_reverse_iterator crbegin() const _NOEXCEPT { return const_reverse_iterator(cend()); }
_LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY
const_reverse_iterator crend() const _NOEXCEPT { return const_reverse_iterator(cbegin()); }
// [string.view.capacity], capacity
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
size_type size() const _NOEXCEPT { return __size; }
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
size_type length() const _NOEXCEPT { return __size; }
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
size_type max_size() const _NOEXCEPT { return numeric_limits<size_type>::max() / sizeof(value_type); }
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
bool empty() const _NOEXCEPT { return __size == 0; }
// [string.view.access], element access
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
const_reference operator[](size_type __pos) const _NOEXCEPT {
return _LIBCPP_ASSERT(__pos < size(), "string_view[] index out of bounds"), __data[__pos];
}
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
const_reference at(size_type __pos) const
{
return __pos >= size()
? (__throw_out_of_range("string_view::at"), __data[0])
: __data[__pos];
}
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
const_reference front() const _NOEXCEPT
{
return _LIBCPP_ASSERT(!empty(), "string_view::front(): string is empty"), __data[0];
}
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
const_reference back() const _NOEXCEPT
{
return _LIBCPP_ASSERT(!empty(), "string_view::back(): string is empty"), __data[__size-1];
}
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
const_pointer data() const _NOEXCEPT { return __data; }
// [string.view.modifiers], modifiers:
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
void remove_prefix(size_type __n) _NOEXCEPT
{
_LIBCPP_ASSERT(__n <= size(), "remove_prefix() can't remove more than size()");
__data += __n;
__size -= __n;
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
void remove_suffix(size_type __n) _NOEXCEPT
{
_LIBCPP_ASSERT(__n <= size(), "remove_suffix() can't remove more than size()");
__size -= __n;
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
void swap(basic_string_view& __other) _NOEXCEPT
{
const value_type *__p = __data;
__data = __other.__data;
__other.__data = __p;
size_type __sz = __size;
__size = __other.__size;
__other.__size = __sz;
}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const
{
if (__pos > size())
__throw_out_of_range("string_view::copy");
size_type __rlen = _VSTD::min(__n, size() - __pos);
_Traits::copy(__s, data() + __pos, __rlen);
return __rlen;
}
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
basic_string_view substr(size_type __pos = 0, size_type __n = npos) const
{
return __pos > size()
? (__throw_out_of_range("string_view::substr"), basic_string_view())
: basic_string_view(data() + __pos, _VSTD::min(__n, size() - __pos));
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 int compare(basic_string_view __sv) const _NOEXCEPT
{
size_type __rlen = _VSTD::min( size(), __sv.size());
int __retval = _Traits::compare(data(), __sv.data(), __rlen);
if ( __retval == 0 ) // first __rlen chars matched
__retval = size() == __sv.size() ? 0 : ( size() < __sv.size() ? -1 : 1 );
return __retval;
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
int compare(size_type __pos1, size_type __n1, basic_string_view __sv) const
{
return substr(__pos1, __n1).compare(__sv);
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
int compare( size_type __pos1, size_type __n1,
basic_string_view __sv, size_type __pos2, size_type __n2) const
{
return substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
int compare(const _CharT* __s) const _NOEXCEPT
{
return compare(basic_string_view(__s));
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
int compare(size_type __pos1, size_type __n1, const _CharT* __s) const
{
return substr(__pos1, __n1).compare(basic_string_view(__s));
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
int compare(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) const
{
return substr(__pos1, __n1).compare(basic_string_view(__s, __n2));
}
// find
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __s.data(), __pos, __s.size());
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find(_CharT __c, size_type __pos = 0) const _NOEXCEPT
{
return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos);
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
{
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find(): received nullptr");
return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n);
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find(const _CharT* __s, size_type __pos = 0) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s != nullptr, "string_view::find(): received nullptr");
return __str_find<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s));
}
// rfind
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type rfind(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __s.data(), __pos, __s.size());
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type rfind(_CharT __c, size_type __pos = npos) const _NOEXCEPT
{
return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos);
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
{
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::rfind(): received nullptr");
return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n);
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type rfind(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s != nullptr, "string_view::rfind(): received nullptr");
return __str_rfind<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s));
}
// find_first_of
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_first_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_of(): received nullptr");
return __str_find_first_of<value_type, size_type, traits_type, npos>
(data(), size(), __s.data(), __pos, __s.size());
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_first_of(_CharT __c, size_type __pos = 0) const _NOEXCEPT
{ return find(__c, __pos); }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
{
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_of(): received nullptr");
return __str_find_first_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n);
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_first_of(const _CharT* __s, size_type __pos=0) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_of(): received nullptr");
return __str_find_first_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s));
}
// find_last_of
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_last_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_of(): received nullptr");
return __str_find_last_of<value_type, size_type, traits_type, npos>
(data(), size(), __s.data(), __pos, __s.size());
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_last_of(_CharT __c, size_type __pos = npos) const _NOEXCEPT
{ return rfind(__c, __pos); }
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
{
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_of(): received nullptr");
return __str_find_last_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n);
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_last_of(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_of(): received nullptr");
return __str_find_last_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s));
}
// find_first_not_of
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_first_not_of(basic_string_view __s, size_type __pos=0) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_not_of(): received nullptr");
return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s.data(), __pos, __s.size());
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_first_not_of(_CharT __c, size_type __pos=0) const _NOEXCEPT
{
return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos);
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
{
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_not_of(): received nullptr");
return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n);
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_first_not_of(const _CharT* __s, size_type __pos=0) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_not_of(): received nullptr");
return __str_find_first_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s));
}
// find_last_not_of
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_not_of(): received nullptr");
return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s.data(), __pos, __s.size());
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(_CharT __c, size_type __pos=npos) const _NOEXCEPT
{
return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __c, __pos);
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
{
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_not_of(): received nullptr");
return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, __n);
}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT
{
_LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_not_of(): received nullptr");
return __str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s));
}
#if _LIBCPP_STD_VER > 17
constexpr _LIBCPP_INLINE_VISIBILITY
bool starts_with(basic_string_view __s) const noexcept
{ return size() >= __s.size() && compare(0, __s.size(), __s) == 0; }
constexpr _LIBCPP_INLINE_VISIBILITY
bool starts_with(value_type __c) const noexcept
{ return !empty() && _Traits::eq(front(), __c); }
constexpr _LIBCPP_INLINE_VISIBILITY
bool starts_with(const value_type* __s) const noexcept
{ return starts_with(basic_string_view(__s)); }
constexpr _LIBCPP_INLINE_VISIBILITY
bool ends_with(basic_string_view __s) const noexcept
{ return size() >= __s.size() && compare(size() - __s.size(), npos, __s) == 0; }
constexpr _LIBCPP_INLINE_VISIBILITY
bool ends_with(value_type __c) const noexcept
{ return !empty() && _Traits::eq(back(), __c); }
constexpr _LIBCPP_INLINE_VISIBILITY
bool ends_with(const value_type* __s) const noexcept
{ return ends_with(basic_string_view(__s)); }
#endif
#if _LIBCPP_STD_VER > 20
constexpr _LIBCPP_INLINE_VISIBILITY
bool contains(basic_string_view __sv) const noexcept
{ return find(__sv) != npos; }
constexpr _LIBCPP_INLINE_VISIBILITY
bool contains(value_type __c) const noexcept
{ return find(__c) != npos; }
constexpr _LIBCPP_INLINE_VISIBILITY
bool contains(const value_type* __s) const
{ return find(__s) != npos; }
#endif
private:
const value_type* __data;
size_type __size;
};
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _CharT, class _Traits>
inline constexpr bool ranges::enable_view<basic_string_view<_CharT, _Traits>> = true;
template <class _CharT, class _Traits>
inline constexpr bool ranges::enable_borrowed_range<basic_string_view<_CharT, _Traits> > = true;
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [string.view.deduct]
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <contiguous_iterator _It, sized_sentinel_for<_It> _End>
basic_string_view(_It, _End) -> basic_string_view<iter_value_t<_It>>;
#endif
#if _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <ranges::contiguous_range _Range>
basic_string_view(_Range) -> basic_string_view<ranges::range_value_t<_Range>>;
#endif
// [string.view.comparison]
// operator ==
template<class _CharT, class _Traits>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
bool operator==(basic_string_view<_CharT, _Traits> __lhs,
basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{
if ( __lhs.size() != __rhs.size()) return false;
return __lhs.compare(__rhs) == 0;
}
// The dummy default template parameters are used to work around a MSVC issue with mangling, see VSO-409326 for details.
// This applies to the other sufficient overloads below for the other comparison operators.
template<class _CharT, class _Traits, int = 1>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
bool operator==(basic_string_view<_CharT, _Traits> __lhs,
typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
{
if ( __lhs.size() != __rhs.size()) return false;
return __lhs.compare(__rhs) == 0;
}
template<class _CharT, class _Traits, int = 2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
bool operator==(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{
if ( __lhs.size() != __rhs.size()) return false;
return __lhs.compare(__rhs) == 0;
}
// operator !=
template<class _CharT, class _Traits>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
bool operator!=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{
if ( __lhs.size() != __rhs.size())
return true;
return __lhs.compare(__rhs) != 0;
}
template<class _CharT, class _Traits, int = 1>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
bool operator!=(basic_string_view<_CharT, _Traits> __lhs,
typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
{
if ( __lhs.size() != __rhs.size())
return true;
return __lhs.compare(__rhs) != 0;
}
template<class _CharT, class _Traits, int = 2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
bool operator!=(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{
if ( __lhs.size() != __rhs.size())
return true;
return __lhs.compare(__rhs) != 0;
}
// operator <
template<class _CharT, class _Traits>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
bool operator<(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{
return __lhs.compare(__rhs) < 0;
}
template<class _CharT, class _Traits, int = 1>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
bool operator<(basic_string_view<_CharT, _Traits> __lhs,
typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
{
return __lhs.compare(__rhs) < 0;
}
template<class _CharT, class _Traits, int = 2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
bool operator<(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{
return __lhs.compare(__rhs) < 0;
}
// operator >
template<class _CharT, class _Traits>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
bool operator> (basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{
return __lhs.compare(__rhs) > 0;
}
template<class _CharT, class _Traits, int = 1>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
bool operator>(basic_string_view<_CharT, _Traits> __lhs,
typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
{
return __lhs.compare(__rhs) > 0;
}
template<class _CharT, class _Traits, int = 2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
bool operator>(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{
return __lhs.compare(__rhs) > 0;
}
// operator <=
template<class _CharT, class _Traits>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
bool operator<=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{
return __lhs.compare(__rhs) <= 0;
}
template<class _CharT, class _Traits, int = 1>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
bool operator<=(basic_string_view<_CharT, _Traits> __lhs,
typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
{
return __lhs.compare(__rhs) <= 0;
}
template<class _CharT, class _Traits, int = 2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
bool operator<=(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{
return __lhs.compare(__rhs) <= 0;
}
// operator >=
template<class _CharT, class _Traits>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
bool operator>=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{
return __lhs.compare(__rhs) >= 0;
}
template<class _CharT, class _Traits, int = 1>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
bool operator>=(basic_string_view<_CharT, _Traits> __lhs,
typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
{
return __lhs.compare(__rhs) >= 0;
}
template<class _CharT, class _Traits, int = 2>
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
bool operator>=(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{
return __lhs.compare(__rhs) >= 0;
}
template<class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os,
basic_string_view<_CharT, _Traits> __str);
// [string.view.hash]
template<class _CharT>
struct _LIBCPP_TEMPLATE_VIS hash<basic_string_view<_CharT, char_traits<_CharT> > >
: public unary_function<basic_string_view<_CharT, char_traits<_CharT> >, size_t>
{
_LIBCPP_INLINE_VISIBILITY
size_t operator()(const basic_string_view<_CharT, char_traits<_CharT> > __val) const _NOEXCEPT {
return __do_string_hash(__val.data(), __val.data() + __val.size());
}
};
#if _LIBCPP_STD_VER > 11
inline namespace literals
{
inline namespace string_view_literals
{
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
basic_string_view<char> operator "" sv(const char *__str, size_t __len) _NOEXCEPT
{
return basic_string_view<char> (__str, __len);
}
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
basic_string_view<wchar_t> operator "" sv(const wchar_t *__str, size_t __len) _NOEXCEPT
{
return basic_string_view<wchar_t> (__str, __len);
}
#endif
#ifndef _LIBCPP_HAS_NO_CHAR8_T
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
basic_string_view<char8_t> operator "" sv(const char8_t *__str, size_t __len) _NOEXCEPT
{
return basic_string_view<char8_t> (__str, __len);
}
#endif
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
basic_string_view<char16_t> operator "" sv(const char16_t *__str, size_t __len) _NOEXCEPT
{
return basic_string_view<char16_t> (__str, __len);
}
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
basic_string_view<char32_t> operator "" sv(const char32_t *__str, size_t __len) _NOEXCEPT
{
return basic_string_view<char32_t> (__str, __len);
}
} // namespace string_view_literals
} // namespace literals
#endif
_LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS
#endif // _LIBCPP_STRING_VIEW
diff --git a/contrib/llvm-project/libcxx/include/tuple b/contrib/llvm-project/libcxx/include/tuple
index 5cf120fec359..6f3368ca301f 100644
--- a/contrib/llvm-project/libcxx/include/tuple
+++ b/contrib/llvm-project/libcxx/include/tuple
@@ -1,1633 +1,1633 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_TUPLE
#define _LIBCPP_TUPLE
/*
tuple synopsis
namespace std
{
template <class... T>
class tuple {
public:
explicit(see-below) constexpr tuple();
explicit(see-below) tuple(const T&...); // constexpr in C++14
template <class... U>
explicit(see-below) tuple(U&&...); // constexpr in C++14
tuple(const tuple&) = default;
tuple(tuple&&) = default;
template <class... U>
explicit(see-below) tuple(const tuple<U...>&); // constexpr in C++14
template <class... U>
explicit(see-below) tuple(tuple<U...>&&); // constexpr in C++14
template <class U1, class U2>
explicit(see-below) tuple(const pair<U1, U2>&); // iff sizeof...(T) == 2 // constexpr in C++14
template <class U1, class U2>
explicit(see-below) tuple(pair<U1, U2>&&); // iff sizeof...(T) == 2 // constexpr in C++14
// allocator-extended constructors
template <class Alloc>
tuple(allocator_arg_t, const Alloc& a);
template <class Alloc>
explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const T&...); // constexpr in C++20
template <class Alloc, class... U>
explicit(see-below) tuple(allocator_arg_t, const Alloc& a, U&&...); // constexpr in C++20
template <class Alloc>
tuple(allocator_arg_t, const Alloc& a, const tuple&); // constexpr in C++20
template <class Alloc>
tuple(allocator_arg_t, const Alloc& a, tuple&&); // constexpr in C++20
template <class Alloc, class... U>
explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const tuple<U...>&); // constexpr in C++20
template <class Alloc, class... U>
explicit(see-below) tuple(allocator_arg_t, const Alloc& a, tuple<U...>&&); // constexpr in C++20
template <class Alloc, class U1, class U2>
explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&); // constexpr in C++20
template <class Alloc, class U1, class U2>
explicit(see-below) tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&); // constexpr in C++20
tuple& operator=(const tuple&); // constexpr in C++20
tuple& operator=(tuple&&) noexcept(is_nothrow_move_assignable_v<T> && ...); // constexpr in C++20
template <class... U>
tuple& operator=(const tuple<U...>&); // constexpr in C++20
template <class... U>
tuple& operator=(tuple<U...>&&); // constexpr in C++20
template <class U1, class U2>
tuple& operator=(const pair<U1, U2>&); // iff sizeof...(T) == 2 // constexpr in C++20
template <class U1, class U2>
tuple& operator=(pair<U1, U2>&&); // iff sizeof...(T) == 2 // constexpr in C++20
template<class U, size_t N>
tuple& operator=(array<U, N> const&) // iff sizeof...(T) == N, EXTENSION
template<class U, size_t N>
tuple& operator=(array<U, N>&&) // iff sizeof...(T) == N, EXTENSION
void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...)); // constexpr in C++20
};
template<class... TTypes, class... UTypes, template<class> class TQual, template<class> class UQual> // since C++23
requires requires { typename tuple<common_reference_t<TQual<TTypes>, UQual<UTypes>>...>; }
struct basic_common_reference<tuple<TTypes...>, tuple<UTypes...>, TQual, UQual> {
using type = tuple<common_reference_t<TQual<TTypes>, UQual<UTypes>>...>;
};
template<class... TTypes, class... UTypes> // since C++23
requires requires { typename tuple<common_type_t<TTypes, UTypes>...>; }
struct common_type<tuple<TTypes...>, tuple<UTypes...>> {
using type = tuple<common_type_t<TTypes, UTypes>...>;
};
template <class ...T>
tuple(T...) -> tuple<T...>; // since C++17
template <class T1, class T2>
tuple(pair<T1, T2>) -> tuple<T1, T2>; // since C++17
template <class Alloc, class ...T>
tuple(allocator_arg_t, Alloc, T...) -> tuple<T...>; // since C++17
template <class Alloc, class T1, class T2>
tuple(allocator_arg_t, Alloc, pair<T1, T2>) -> tuple<T1, T2>; // since C++17
template <class Alloc, class ...T>
tuple(allocator_arg_t, Alloc, tuple<T...>) -> tuple<T...>; // since C++17
inline constexpr unspecified ignore;
template <class... T> tuple<V...> make_tuple(T&&...); // constexpr in C++14
template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept; // constexpr in C++14
template <class... T> tuple<T&...> tie(T&...) noexcept; // constexpr in C++14
template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls); // constexpr in C++14
// [tuple.apply], calling a function with a tuple of arguments:
template <class F, class Tuple>
constexpr decltype(auto) apply(F&& f, Tuple&& t); // C++17
template <class T, class Tuple>
constexpr T make_from_tuple(Tuple&& t); // C++17
// 20.4.1.4, tuple helper classes:
template <class T> struct tuple_size; // undefined
template <class... T> struct tuple_size<tuple<T...>>;
template <class T>
inline constexpr size_t tuple_size_v = tuple_size<T>::value; // C++17
template <size_t I, class T> struct tuple_element; // undefined
template <size_t I, class... T> struct tuple_element<I, tuple<T...>>;
template <size_t I, class T>
using tuple_element_t = typename tuple_element <I, T>::type; // C++14
// 20.4.1.5, element access:
template <size_t I, class... T>
typename tuple_element<I, tuple<T...>>::type&
get(tuple<T...>&) noexcept; // constexpr in C++14
template <size_t I, class... T>
const typename tuple_element<I, tuple<T...>>::type&
get(const tuple<T...>&) noexcept; // constexpr in C++14
template <size_t I, class... T>
typename tuple_element<I, tuple<T...>>::type&&
get(tuple<T...>&&) noexcept; // constexpr in C++14
template <size_t I, class... T>
const typename tuple_element<I, tuple<T...>>::type&&
get(const tuple<T...>&&) noexcept; // constexpr in C++14
template <class T1, class... T>
constexpr T1& get(tuple<T...>&) noexcept; // C++14
template <class T1, class... T>
constexpr const T1& get(const tuple<T...>&) noexcept; // C++14
template <class T1, class... T>
constexpr T1&& get(tuple<T...>&&) noexcept; // C++14
template <class T1, class... T>
constexpr const T1&& get(const tuple<T...>&&) noexcept; // C++14
// 20.4.1.6, relational operators:
template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14, removed in C++20
template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14, removed in C++20
template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14, removed in C++20
template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14, removed in C++20
template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14, removed in C++20
template<class... T, class... U>
constexpr common_comparison_category_t<synth-three-way-result<T, U>...>
operator<=>(const tuple<T...>&, const tuple<U...>&); // since C++20
template <class... Types, class Alloc>
struct uses_allocator<tuple<Types...>, Alloc>;
template <class... Types>
void
swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(noexcept(x.swap(y)));
} // std
*/
#include <__compare/common_comparison_category.h>
#include <__compare/synth_three_way.h>
#include <__config>
#include <__functional/unwrap_ref.h>
#include <__functional_base>
#include <__memory/allocator_arg_t.h>
#include <__memory/uses_allocator.h>
#include <__tuple>
#include <__utility/forward.h>
#include <__utility/integer_sequence.h>
#include <__utility/move.h>
#include <compare>
#include <cstddef>
#include <type_traits>
#include <utility>
#include <version>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
#ifndef _LIBCPP_CXX03_LANG
// __tuple_leaf
template <size_t _Ip, class _Hp,
bool=is_empty<_Hp>::value && !__libcpp_is_final<_Hp>::value
>
class __tuple_leaf;
template <size_t _Ip, class _Hp, bool _Ep>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
_NOEXCEPT_(__is_nothrow_swappable<_Hp>::value)
{
swap(__x.get(), __y.get());
}
template <size_t _Ip, class _Hp, bool>
class __tuple_leaf
{
_Hp __value_;
template <class _Tp>
static constexpr bool __can_bind_reference() {
#if __has_keyword(__reference_binds_to_temporary)
return !__reference_binds_to_temporary(_Hp, _Tp);
#else
return true;
#endif
}
_LIBCPP_CONSTEXPR_AFTER_CXX11
__tuple_leaf& operator=(const __tuple_leaf&);
public:
_LIBCPP_INLINE_VISIBILITY constexpr __tuple_leaf()
_NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) : __value_()
{static_assert(!is_reference<_Hp>::value,
"Attempted to default construct a reference element in a tuple");}
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY constexpr
__tuple_leaf(integral_constant<int, 0>, const _Alloc&)
: __value_()
{static_assert(!is_reference<_Hp>::value,
"Attempted to default construct a reference element in a tuple");}
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY constexpr
__tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
: __value_(allocator_arg_t(), __a)
{static_assert(!is_reference<_Hp>::value,
"Attempted to default construct a reference element in a tuple");}
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY constexpr
__tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
: __value_(__a)
{static_assert(!is_reference<_Hp>::value,
"Attempted to default construct a reference element in a tuple");}
template <class _Tp,
class = __enable_if_t<
_And<
_IsNotSame<__uncvref_t<_Tp>, __tuple_leaf>,
is_constructible<_Hp, _Tp>
>::value
>
>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
: __value_(_VSTD::forward<_Tp>(__t))
{static_assert(__can_bind_reference<_Tp&&>(),
"Attempted construction of reference element binds to a temporary whose lifetime has ended");}
template <class _Tp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
: __value_(_VSTD::forward<_Tp>(__t))
{static_assert(__can_bind_reference<_Tp&&>(),
"Attempted construction of reference element binds to a temporary whose lifetime has ended");}
template <class _Tp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
: __value_(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t))
{static_assert(!is_reference<_Hp>::value,
"Attempted to uses-allocator construct a reference element in a tuple");}
template <class _Tp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
: __value_(_VSTD::forward<_Tp>(__t), __a)
{static_assert(!is_reference<_Hp>::value,
"Attempted to uses-allocator construct a reference element in a tuple");}
__tuple_leaf(const __tuple_leaf& __t) = default;
__tuple_leaf(__tuple_leaf&& __t) = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
{
_VSTD::swap(*this, __t);
return 0;
}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Hp& get() _NOEXCEPT {return __value_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return __value_;}
};
template <size_t _Ip, class _Hp>
class __tuple_leaf<_Ip, _Hp, true>
: private _Hp
{
_LIBCPP_CONSTEXPR_AFTER_CXX11
__tuple_leaf& operator=(const __tuple_leaf&);
public:
_LIBCPP_INLINE_VISIBILITY constexpr __tuple_leaf()
_NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) {}
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY constexpr
__tuple_leaf(integral_constant<int, 0>, const _Alloc&) {}
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY constexpr
__tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
: _Hp(allocator_arg_t(), __a) {}
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY constexpr
__tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
: _Hp(__a) {}
template <class _Tp,
class = __enable_if_t<
_And<
_IsNotSame<__uncvref_t<_Tp>, __tuple_leaf>,
is_constructible<_Hp, _Tp>
>::value
>
>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
: _Hp(_VSTD::forward<_Tp>(__t)) {}
template <class _Tp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY constexpr
explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
: _Hp(_VSTD::forward<_Tp>(__t)) {}
template <class _Tp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY constexpr
explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
: _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {}
template <class _Tp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY constexpr
explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
: _Hp(_VSTD::forward<_Tp>(__t), __a) {}
__tuple_leaf(__tuple_leaf const &) = default;
__tuple_leaf(__tuple_leaf &&) = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
int
swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
{
_VSTD::swap(*this, __t);
return 0;
}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Hp& get() _NOEXCEPT {return static_cast<_Hp&>(*this);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return static_cast<const _Hp&>(*this);}
};
template <class ..._Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
void __swallow(_Tp&&...) _NOEXCEPT {}
template <class _Tp>
struct __all_default_constructible;
template <class ..._Tp>
struct __all_default_constructible<__tuple_types<_Tp...>>
: __all<is_default_constructible<_Tp>::value...>
{ };
// __tuple_impl
template<class _Indx, class ..._Tp> struct __tuple_impl;
template<size_t ..._Indx, class ..._Tp>
struct _LIBCPP_DECLSPEC_EMPTY_BASES __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
: public __tuple_leaf<_Indx, _Tp>...
{
_LIBCPP_INLINE_VISIBILITY
constexpr __tuple_impl()
_NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
template <size_t ..._Uf, class ..._Tf,
size_t ..._Ul, class ..._Tl, class ..._Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit
__tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
__tuple_indices<_Ul...>, __tuple_types<_Tl...>,
_Up&&... __u)
_NOEXCEPT_((__all<is_nothrow_constructible<_Tf, _Up>::value...>::value &&
__all<is_nothrow_default_constructible<_Tl>::value...>::value)) :
__tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))...,
__tuple_leaf<_Ul, _Tl>()...
{}
template <class _Alloc, size_t ..._Uf, class ..._Tf,
size_t ..._Ul, class ..._Tl, class ..._Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit
__tuple_impl(allocator_arg_t, const _Alloc& __a,
__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
__tuple_indices<_Ul...>, __tuple_types<_Tl...>,
_Up&&... __u) :
__tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a,
_VSTD::forward<_Up>(__u))...,
__tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)...
{}
template <class _Tuple,
class = typename enable_if
<
__tuple_constructible<_Tuple, tuple<_Tp...> >::value
>::type
>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
__tuple_impl(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_constructible<_Tp, typename tuple_element<_Indx,
typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
: __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx,
typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
{}
template <class _Alloc, class _Tuple,
class = typename enable_if
<
__tuple_constructible<_Tuple, tuple<_Tp...> >::value
>::type
>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
__tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
: __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
typename __make_tuple_types<_Tuple>::type>::type>(), __a,
_VSTD::forward<typename tuple_element<_Indx,
typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
{}
__tuple_impl(const __tuple_impl&) = default;
__tuple_impl(__tuple_impl&&) = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
void swap(__tuple_impl& __t)
_NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
{
_VSTD::__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
}
};
template<class _Dest, class _Source, size_t ..._Np>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
void __memberwise_copy_assign(_Dest& __dest, _Source const& __source, __tuple_indices<_Np...>) {
_VSTD::__swallow(((_VSTD::get<_Np>(__dest) = _VSTD::get<_Np>(__source)), void(), 0)...);
}
template<class _Dest, class _Source, class ..._Up, size_t ..._Np>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
void __memberwise_forward_assign(_Dest& __dest, _Source&& __source, __tuple_types<_Up...>, __tuple_indices<_Np...>) {
_VSTD::__swallow(((
_VSTD::get<_Np>(__dest) = _VSTD::forward<_Up>(_VSTD::get<_Np>(__source))
), void(), 0)...);
}
template <class ..._Tp>
class _LIBCPP_TEMPLATE_VIS tuple
{
typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> _BaseT;
_BaseT __base_;
template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT;
template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&) _NOEXCEPT;
template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT;
template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
const typename tuple_element<_Jp, tuple<_Up...> >::type&& get(const tuple<_Up...>&&) _NOEXCEPT;
public:
// [tuple.cnstr]
// tuple() constructors (including allocator_arg_t variants)
template <template<class...> class _IsImpDefault = __is_implicitly_default_constructible, __enable_if_t<
_And<
_IsImpDefault<_Tp>... // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
tuple()
_NOEXCEPT_(_And<is_nothrow_default_constructible<_Tp>...>::value)
{ }
template <template<class...> class _IsImpDefault = __is_implicitly_default_constructible,
template<class...> class _IsDefault = is_default_constructible, __enable_if_t<
_And<
_IsDefault<_Tp>...,
_Not<_Lazy<_And, _IsImpDefault<_Tp>...> > // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
explicit tuple()
_NOEXCEPT_(_And<is_nothrow_default_constructible<_Tp>...>::value)
{ }
template <class _Alloc, template<class...> class _IsImpDefault = __is_implicitly_default_constructible, __enable_if_t<
_And<
_IsImpDefault<_Tp>... // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, _Alloc const& __a)
: __base_(allocator_arg_t(), __a,
__tuple_indices<>(), __tuple_types<>(),
typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
__tuple_types<_Tp...>()) {}
template <class _Alloc,
template<class...> class _IsImpDefault = __is_implicitly_default_constructible,
template<class...> class _IsDefault = is_default_constructible, __enable_if_t<
_And<
_IsDefault<_Tp>...,
_Not<_Lazy<_And, _IsImpDefault<_Tp>...> > // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
explicit tuple(allocator_arg_t, _Alloc const& __a)
: __base_(allocator_arg_t(), __a,
__tuple_indices<>(), __tuple_types<>(),
typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
__tuple_types<_Tp...>()) {}
// tuple(const T&...) constructors (including allocator_arg_t variants)
template <template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) >= 1>,
is_copy_constructible<_Tp>...,
is_convertible<const _Tp&, _Tp>... // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple(const _Tp& ... __t)
_NOEXCEPT_(_And<is_nothrow_copy_constructible<_Tp>...>::value)
: __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
typename __make_tuple_indices<0>::type(),
typename __make_tuple_types<tuple, 0>::type(),
__t...
) {}
template <template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) >= 1>,
is_copy_constructible<_Tp>...,
_Not<_Lazy<_And, is_convertible<const _Tp&, _Tp>...> > // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit tuple(const _Tp& ... __t)
_NOEXCEPT_(_And<is_nothrow_copy_constructible<_Tp>...>::value)
: __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
typename __make_tuple_indices<0>::type(),
typename __make_tuple_types<tuple, 0>::type(),
__t...
) {}
template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) >= 1>,
is_copy_constructible<_Tp>...,
is_convertible<const _Tp&, _Tp>... // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
: __base_(allocator_arg_t(), __a,
typename __make_tuple_indices<sizeof...(_Tp)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
typename __make_tuple_indices<0>::type(),
typename __make_tuple_types<tuple, 0>::type(),
__t...
) {}
template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) >= 1>,
is_copy_constructible<_Tp>...,
_Not<_Lazy<_And, is_convertible<const _Tp&, _Tp>...> > // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
explicit tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
: __base_(allocator_arg_t(), __a,
typename __make_tuple_indices<sizeof...(_Tp)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
typename __make_tuple_indices<0>::type(),
typename __make_tuple_types<tuple, 0>::type(),
__t...
) {}
// tuple(U&& ...) constructors (including allocator_arg_t variants)
template <class ..._Up> struct _IsThisTuple : false_type { };
template <class _Up> struct _IsThisTuple<_Up> : is_same<__uncvref_t<_Up>, tuple> { };
template <class ..._Up>
struct _EnableUTypesCtor : _And<
_BoolConstant<sizeof...(_Tp) >= 1>,
_Not<_IsThisTuple<_Up...> >, // extension to allow mis-behaved user constructors
is_constructible<_Tp, _Up>...
> { };
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableUTypesCtor<_Up...>,
is_convertible<_Up, _Tp>... // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple(_Up&&... __u)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
: __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
_VSTD::forward<_Up>(__u)...) {}
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableUTypesCtor<_Up...>,
_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit tuple(_Up&&... __u)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
: __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
_VSTD::forward<_Up>(__u)...) {}
template <class _Alloc, class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableUTypesCtor<_Up...>,
is_convertible<_Up, _Tp>... // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
: __base_(allocator_arg_t(), __a,
typename __make_tuple_indices<sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
_VSTD::forward<_Up>(__u)...) {}
template <class _Alloc, class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableUTypesCtor<_Up...>,
_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
explicit tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
: __base_(allocator_arg_t(), __a,
typename __make_tuple_indices<sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
_VSTD::forward<_Up>(__u)...) {}
// Copy and move constructors (including the allocator_arg_t variants)
tuple(const tuple&) = default;
tuple(tuple&&) = default;
template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
_And<is_copy_constructible<_Tp>...>::value
, int> = 0>
tuple(allocator_arg_t, const _Alloc& __alloc, const tuple& __t)
: __base_(allocator_arg_t(), __alloc, __t)
{ }
template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
_And<is_move_constructible<_Tp>...>::value
, int> = 0>
tuple(allocator_arg_t, const _Alloc& __alloc, tuple&& __t)
: __base_(allocator_arg_t(), __alloc, _VSTD::move(__t))
{ }
// tuple(const tuple<U...>&) constructors (including allocator_arg_t variants)
template <class ..._Up>
struct _EnableCopyFromOtherTuple : _And<
_Not<is_same<tuple<_Tp...>, tuple<_Up...> > >,
_Lazy<_Or,
_BoolConstant<sizeof...(_Tp) != 1>,
// _Tp and _Up are 1-element packs - the pack expansions look
// weird to avoid tripping up the type traits in degenerate cases
_Lazy<_And,
_Not<is_convertible<const tuple<_Up>&, _Tp> >...,
_Not<is_constructible<_Tp, const tuple<_Up>&> >...
>
>,
is_constructible<_Tp, const _Up&>...
> { };
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableCopyFromOtherTuple<_Up...>,
is_convertible<const _Up&, _Tp>... // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple(const tuple<_Up...>& __t)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up&>...>::value))
: __base_(__t)
{ }
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableCopyFromOtherTuple<_Up...>,
_Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit tuple(const tuple<_Up...>& __t)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up&>...>::value))
: __base_(__t)
{ }
template <class ..._Up, class _Alloc, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableCopyFromOtherTuple<_Up...>,
is_convertible<const _Up&, _Tp>... // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t)
: __base_(allocator_arg_t(), __a, __t)
{ }
template <class ..._Up, class _Alloc, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableCopyFromOtherTuple<_Up...>,
_Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
explicit tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t)
: __base_(allocator_arg_t(), __a, __t)
{ }
// tuple(tuple<U...>&&) constructors (including allocator_arg_t variants)
template <class ..._Up>
struct _EnableMoveFromOtherTuple : _And<
_Not<is_same<tuple<_Tp...>, tuple<_Up...> > >,
_Lazy<_Or,
_BoolConstant<sizeof...(_Tp) != 1>,
// _Tp and _Up are 1-element packs - the pack expansions look
// weird to avoid tripping up the type traits in degenerate cases
_Lazy<_And,
_Not<is_convertible<tuple<_Up>, _Tp> >...,
_Not<is_constructible<_Tp, tuple<_Up> > >...
>
>,
is_constructible<_Tp, _Up>...
> { };
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableMoveFromOtherTuple<_Up...>,
is_convertible<_Up, _Tp>... // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple(tuple<_Up...>&& __t)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
: __base_(_VSTD::move(__t))
{ }
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableMoveFromOtherTuple<_Up...>,
_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit tuple(tuple<_Up...>&& __t)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
: __base_(_VSTD::move(__t))
{ }
template <class _Alloc, class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableMoveFromOtherTuple<_Up...>,
is_convertible<_Up, _Tp>... // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t)
: __base_(allocator_arg_t(), __a, _VSTD::move(__t))
{ }
template <class _Alloc, class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableMoveFromOtherTuple<_Up...>,
_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
explicit tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t)
: __base_(allocator_arg_t(), __a, _VSTD::move(__t))
{ }
// tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants)
template <class _Up1, class _Up2, class ..._DependentTp>
struct _EnableImplicitCopyFromPair : _And<
is_constructible<_FirstType<_DependentTp...>, const _Up1&>,
is_constructible<_SecondType<_DependentTp...>, const _Up2&>,
is_convertible<const _Up1&, _FirstType<_DependentTp...> >, // explicit check
is_convertible<const _Up2&, _SecondType<_DependentTp...> >
> { };
template <class _Up1, class _Up2, class ..._DependentTp>
struct _EnableExplicitCopyFromPair : _And<
is_constructible<_FirstType<_DependentTp...>, const _Up1&>,
is_constructible<_SecondType<_DependentTp...>, const _Up2&>,
_Not<is_convertible<const _Up1&, _FirstType<_DependentTp...> > >, // explicit check
_Not<is_convertible<const _Up2&, _SecondType<_DependentTp...> > >
> { };
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableImplicitCopyFromPair<_Up1, _Up2, _Tp...>
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple(const pair<_Up1, _Up2>& __p)
_NOEXCEPT_((_And<
is_nothrow_constructible<_FirstType<_Tp...>, const _Up1&>,
is_nothrow_constructible<_SecondType<_Tp...>, const _Up2&>
>::value))
: __base_(__p)
{ }
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitCopyFromPair<_Up1, _Up2, _Tp...>
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit tuple(const pair<_Up1, _Up2>& __p)
_NOEXCEPT_((_And<
is_nothrow_constructible<_FirstType<_Tp...>, const _Up1&>,
is_nothrow_constructible<_SecondType<_Tp...>, const _Up2&>
>::value))
: __base_(__p)
{ }
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableImplicitCopyFromPair<_Up1, _Up2, _Tp...>
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p)
: __base_(allocator_arg_t(), __a, __p)
{ }
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitCopyFromPair<_Up1, _Up2, _Tp...>
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
explicit tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p)
: __base_(allocator_arg_t(), __a, __p)
{ }
// tuple(pair<U1, U2>&&) constructors (including allocator_arg_t variants)
template <class _Up1, class _Up2, class ..._DependentTp>
struct _EnableImplicitMoveFromPair : _And<
is_constructible<_FirstType<_DependentTp...>, _Up1>,
is_constructible<_SecondType<_DependentTp...>, _Up2>,
is_convertible<_Up1, _FirstType<_DependentTp...> >, // explicit check
is_convertible<_Up2, _SecondType<_DependentTp...> >
> { };
template <class _Up1, class _Up2, class ..._DependentTp>
struct _EnableExplicitMoveFromPair : _And<
is_constructible<_FirstType<_DependentTp...>, _Up1>,
is_constructible<_SecondType<_DependentTp...>, _Up2>,
_Not<is_convertible<_Up1, _FirstType<_DependentTp...> > >, // explicit check
_Not<is_convertible<_Up2, _SecondType<_DependentTp...> > >
> { };
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableImplicitMoveFromPair<_Up1, _Up2, _Tp...>
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple(pair<_Up1, _Up2>&& __p)
_NOEXCEPT_((_And<
is_nothrow_constructible<_FirstType<_Tp...>, _Up1>,
is_nothrow_constructible<_SecondType<_Tp...>, _Up2>
>::value))
: __base_(_VSTD::move(__p))
{ }
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitMoveFromPair<_Up1, _Up2, _Tp...>
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit tuple(pair<_Up1, _Up2>&& __p)
_NOEXCEPT_((_And<
is_nothrow_constructible<_FirstType<_Tp...>, _Up1>,
is_nothrow_constructible<_SecondType<_Tp...>, _Up2>
>::value))
: __base_(_VSTD::move(__p))
{ }
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableImplicitMoveFromPair<_Up1, _Up2, _Tp...>
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p)
: __base_(allocator_arg_t(), __a, _VSTD::move(__p))
{ }
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitMoveFromPair<_Up1, _Up2, _Tp...>
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
explicit tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p)
: __base_(allocator_arg_t(), __a, _VSTD::move(__p))
{ }
// [tuple.assign]
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple& operator=(_If<_And<is_copy_assignable<_Tp>...>::value, tuple, __nat> const& __tuple)
_NOEXCEPT_((_And<is_nothrow_copy_assignable<_Tp>...>::value))
{
_VSTD::__memberwise_copy_assign(*this, __tuple,
typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this;
}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple& operator=(_If<_And<is_move_assignable<_Tp>...>::value, tuple, __nat>&& __tuple)
_NOEXCEPT_((_And<is_nothrow_move_assignable<_Tp>...>::value))
{
_VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple),
__tuple_types<_Tp...>(),
typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this;
}
template<class... _Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == sizeof...(_Up)>,
is_assignable<_Tp&, _Up const&>...
>::value
,int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple& operator=(tuple<_Up...> const& __tuple)
_NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value))
{
_VSTD::__memberwise_copy_assign(*this, __tuple,
typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this;
}
template<class... _Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == sizeof...(_Up)>,
is_assignable<_Tp&, _Up>...
>::value
,int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple& operator=(tuple<_Up...>&& __tuple)
_NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up>...>::value))
{
_VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple),
__tuple_types<_Up...>(),
typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this;
}
template<class _Up1, class _Up2, class _Dep = true_type, __enable_if_t<
_And<_Dep,
_BoolConstant<sizeof...(_Tp) == 2>,
is_assignable<_FirstType<_Tp..., _Dep>&, _Up1 const&>,
is_assignable<_SecondType<_Tp..., _Dep>&, _Up2 const&>
>::value
,int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple& operator=(pair<_Up1, _Up2> const& __pair)
_NOEXCEPT_((_And<
is_nothrow_assignable<_FirstType<_Tp...>&, _Up1 const&>,
is_nothrow_assignable<_SecondType<_Tp...>&, _Up2 const&>
>::value))
{
_VSTD::get<0>(*this) = __pair.first;
_VSTD::get<1>(*this) = __pair.second;
return *this;
}
template<class _Up1, class _Up2, class _Dep = true_type, __enable_if_t<
_And<_Dep,
_BoolConstant<sizeof...(_Tp) == 2>,
is_assignable<_FirstType<_Tp..., _Dep>&, _Up1>,
is_assignable<_SecondType<_Tp..., _Dep>&, _Up2>
>::value
,int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple& operator=(pair<_Up1, _Up2>&& __pair)
_NOEXCEPT_((_And<
is_nothrow_assignable<_FirstType<_Tp...>&, _Up1>,
is_nothrow_assignable<_SecondType<_Tp...>&, _Up2>
>::value))
{
_VSTD::get<0>(*this) = _VSTD::forward<_Up1>(__pair.first);
_VSTD::get<1>(*this) = _VSTD::forward<_Up2>(__pair.second);
return *this;
}
// EXTENSION
template<class _Up, size_t _Np, class = __enable_if_t<
_And<
_BoolConstant<_Np == sizeof...(_Tp)>,
is_assignable<_Tp&, _Up const&>...
>::value
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple& operator=(array<_Up, _Np> const& __array)
_NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value))
{
_VSTD::__memberwise_copy_assign(*this, __array,
typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this;
}
// EXTENSION
template<class _Up, size_t _Np, class = void, class = __enable_if_t<
_And<
_BoolConstant<_Np == sizeof...(_Tp)>,
is_assignable<_Tp&, _Up>...
>::value
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple& operator=(array<_Up, _Np>&& __array)
_NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up>...>::value))
{
_VSTD::__memberwise_forward_assign(*this, _VSTD::move(__array),
__tuple_types<_If<true, _Up, _Tp>...>(),
typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this;
}
// [tuple.swap]
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
{__base_.swap(__t.__base_);}
};
template <>
class _LIBCPP_TEMPLATE_VIS tuple<>
{
public:
_LIBCPP_INLINE_VISIBILITY constexpr
tuple() _NOEXCEPT = default;
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {}
template <class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(array<_Up, 0>) _NOEXCEPT {}
template <class _Alloc, class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
void swap(tuple&) _NOEXCEPT {}
};
#if _LIBCPP_STD_VER > 20
template <class... _TTypes, class... _UTypes, template<class> class _TQual, template<class> class _UQual>
requires requires { typename tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>; }
struct basic_common_reference<tuple<_TTypes...>, tuple<_UTypes...>, _TQual, _UQual> {
using type = tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>;
};
template <class... _TTypes, class... _UTypes>
requires requires { typename tuple<common_type_t<_TTypes, _UTypes>...>; }
struct common_type<tuple<_TTypes...>, tuple<_UTypes...>> {
using type = tuple<common_type_t<_TTypes, _UTypes>...>;
};
#endif
#if _LIBCPP_STD_VER > 14
template <class ..._Tp>
tuple(_Tp...) -> tuple<_Tp...>;
template <class _Tp1, class _Tp2>
tuple(pair<_Tp1, _Tp2>) -> tuple<_Tp1, _Tp2>;
template <class _Alloc, class ..._Tp>
tuple(allocator_arg_t, _Alloc, _Tp...) -> tuple<_Tp...>;
template <class _Alloc, class _Tp1, class _Tp2>
tuple(allocator_arg_t, _Alloc, pair<_Tp1, _Tp2>) -> tuple<_Tp1, _Tp2>;
template <class _Alloc, class ..._Tp>
tuple(allocator_arg_t, _Alloc, tuple<_Tp...>) -> tuple<_Tp...>;
#endif
template <class ..._Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
typename enable_if
<
__all<__is_swappable<_Tp>::value...>::value,
void
>::type
swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
_NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
{__t.swap(__u);}
// get
template <size_t _Ip, class ..._Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
typename tuple_element<_Ip, tuple<_Tp...> >::type&
get(tuple<_Tp...>& __t) _NOEXCEPT
{
typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
return static_cast<__tuple_leaf<_Ip, type>&>(__t.__base_).get();
}
template <size_t _Ip, class ..._Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
const typename tuple_element<_Ip, tuple<_Tp...> >::type&
get(const tuple<_Tp...>& __t) _NOEXCEPT
{
typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
return static_cast<const __tuple_leaf<_Ip, type>&>(__t.__base_).get();
}
template <size_t _Ip, class ..._Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
typename tuple_element<_Ip, tuple<_Tp...> >::type&&
get(tuple<_Tp...>&& __t) _NOEXCEPT
{
typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
return static_cast<type&&>(
static_cast<__tuple_leaf<_Ip, type>&&>(__t.__base_).get());
}
template <size_t _Ip, class ..._Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
get(const tuple<_Tp...>&& __t) _NOEXCEPT
{
typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
return static_cast<const type&&>(
static_cast<const __tuple_leaf<_Ip, type>&&>(__t.__base_).get());
}
#if _LIBCPP_STD_VER > 11
namespace __find_detail {
static constexpr size_t __not_found = static_cast<size_t>(-1);
static constexpr size_t __ambiguous = __not_found - 1;
inline _LIBCPP_INLINE_VISIBILITY
constexpr size_t __find_idx_return(size_t __curr_i, size_t __res, bool __matches) {
return !__matches ? __res :
(__res == __not_found ? __curr_i : __ambiguous);
}
template <size_t _Nx>
inline _LIBCPP_INLINE_VISIBILITY
constexpr size_t __find_idx(size_t __i, const bool (&__matches)[_Nx]) {
return __i == _Nx ? __not_found :
__find_idx_return(__i, __find_idx(__i + 1, __matches), __matches[__i]);
}
template <class _T1, class ..._Args>
struct __find_exactly_one_checked {
static constexpr bool __matches[sizeof...(_Args)] = {is_same<_T1, _Args>::value...};
static constexpr size_t value = __find_detail::__find_idx(0, __matches);
static_assert(value != __not_found, "type not found in type list" );
static_assert(value != __ambiguous, "type occurs more than once in type list");
};
template <class _T1>
struct __find_exactly_one_checked<_T1> {
static_assert(!is_same<_T1, _T1>::value, "type not in empty type list");
};
} // namespace __find_detail
template <typename _T1, typename... _Args>
struct __find_exactly_one_t
: public __find_detail::__find_exactly_one_checked<_T1, _Args...> {
};
template <class _T1, class... _Args>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1& get(tuple<_Args...>& __tup) noexcept
{
return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
}
template <class _T1, class... _Args>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1 const& get(tuple<_Args...> const& __tup) noexcept
{
return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
}
template <class _T1, class... _Args>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1&& get(tuple<_Args...>&& __tup) noexcept
{
return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup));
}
template <class _T1, class... _Args>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1 const&& get(tuple<_Args...> const&& __tup) noexcept
{
return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup));
}
#endif
// tie
template <class ..._Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple<_Tp&...>
tie(_Tp&... __t) _NOEXCEPT
{
return tuple<_Tp&...>(__t...);
}
template <class _Up>
struct __ignore_t
{
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
const __ignore_t& operator=(_Tp&&) const {return *this;}
};
namespace {
constexpr __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>();
} // namespace
template <class... _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple<typename __unwrap_ref_decay<_Tp>::type...>
make_tuple(_Tp&&... __t)
{
return tuple<typename __unwrap_ref_decay<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
}
template <class... _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple<_Tp&&...>
forward_as_tuple(_Tp&&... __t) _NOEXCEPT
{
return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);
}
template <size_t _Ip>
struct __tuple_equal
{
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool operator()(const _Tp& __x, const _Up& __y)
{
return __tuple_equal<_Ip - 1>()(__x, __y) && _VSTD::get<_Ip-1>(__x) == _VSTD::get<_Ip-1>(__y);
}
};
template <>
struct __tuple_equal<0>
{
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool operator()(const _Tp&, const _Up&)
{
return true;
}
};
template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{
static_assert (sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
}
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// operator<=>
template <class ..._Tp, class ..._Up, size_t ..._Is>
_LIBCPP_HIDE_FROM_ABI constexpr
auto
__tuple_compare_three_way(const tuple<_Tp...>& __x, const tuple<_Up...>& __y, index_sequence<_Is...>) {
common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...> __result = strong_ordering::equal;
static_cast<void>(((__result = _VSTD::__synth_three_way(_VSTD::get<_Is>(__x), _VSTD::get<_Is>(__y)), __result != 0) || ...));
return __result;
}
template <class ..._Tp, class ..._Up>
requires (sizeof...(_Tp) == sizeof...(_Up))
_LIBCPP_HIDE_FROM_ABI constexpr
common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...>
operator<=>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{
return _VSTD::__tuple_compare_three_way(__x, __y, index_sequence_for<_Tp...>{});
}
-#else // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#else // !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{
return !(__x == __y);
}
template <size_t _Ip>
struct __tuple_less
{
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool operator()(const _Tp& __x, const _Up& __y)
{
const size_t __idx = tuple_size<_Tp>::value - _Ip;
if (_VSTD::get<__idx>(__x) < _VSTD::get<__idx>(__y))
return true;
if (_VSTD::get<__idx>(__y) < _VSTD::get<__idx>(__x))
return false;
return __tuple_less<_Ip-1>()(__x, __y);
}
};
template <>
struct __tuple_less<0>
{
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool operator()(const _Tp&, const _Up&)
{
return false;
}
};
template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{
static_assert (sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
return __tuple_less<sizeof...(_Tp)>()(__x, __y);
}
template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{
return __y < __x;
}
template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{
return !(__x < __y);
}
template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{
return !(__y < __x);
}
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
// tuple_cat
template <class _Tp, class _Up> struct __tuple_cat_type;
template <class ..._Ttypes, class ..._Utypes>
struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> >
{
typedef _LIBCPP_NODEBUG tuple<_Ttypes..., _Utypes...> type;
};
template <class _ResultTuple, bool _Is_Tuple0TupleLike, class ..._Tuples>
struct __tuple_cat_return_1
{
};
template <class ..._Types, class _Tuple0>
struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0>
{
typedef _LIBCPP_NODEBUG typename __tuple_cat_type<tuple<_Types...>,
typename __make_tuple_types<typename __uncvref<_Tuple0>::type>::type>::type
type;
};
template <class ..._Types, class _Tuple0, class _Tuple1, class ..._Tuples>
struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...>
: public __tuple_cat_return_1<
typename __tuple_cat_type<
tuple<_Types...>,
typename __make_tuple_types<typename __uncvref<_Tuple0>::type>::type
>::type,
__tuple_like<typename remove_reference<_Tuple1>::type>::value,
_Tuple1, _Tuples...>
{
};
template <class ..._Tuples> struct __tuple_cat_return;
template <class _Tuple0, class ..._Tuples>
struct __tuple_cat_return<_Tuple0, _Tuples...>
: public __tuple_cat_return_1<tuple<>,
__tuple_like<typename remove_reference<_Tuple0>::type>::value, _Tuple0,
_Tuples...>
{
};
template <>
struct __tuple_cat_return<>
{
typedef _LIBCPP_NODEBUG tuple<> type;
};
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple<>
tuple_cat()
{
return tuple<>();
}
template <class _Rp, class _Indices, class _Tuple0, class ..._Tuples>
struct __tuple_cat_return_ref_imp;
template <class ..._Types, size_t ..._I0, class _Tuple0>
struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0>
{
typedef _LIBCPP_NODEBUG typename remove_reference<_Tuple0>::type _T0;
typedef tuple<_Types..., typename __apply_cv<_Tuple0,
typename tuple_element<_I0, _T0>::type>::type&&...> type;
};
template <class ..._Types, size_t ..._I0, class _Tuple0, class _Tuple1, class ..._Tuples>
struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>,
_Tuple0, _Tuple1, _Tuples...>
: public __tuple_cat_return_ref_imp<
tuple<_Types..., typename __apply_cv<_Tuple0,
typename tuple_element<_I0,
typename remove_reference<_Tuple0>::type>::type>::type&&...>,
typename __make_tuple_indices<tuple_size<typename
remove_reference<_Tuple1>::type>::value>::type,
_Tuple1, _Tuples...>
{
};
template <class _Tuple0, class ..._Tuples>
struct __tuple_cat_return_ref
: public __tuple_cat_return_ref_imp<tuple<>,
typename __make_tuple_indices<
tuple_size<typename remove_reference<_Tuple0>::type>::value
>::type, _Tuple0, _Tuples...>
{
};
template <class _Types, class _I0, class _J0>
struct __tuple_cat;
template <class ..._Types, size_t ..._I0, size_t ..._J0>
struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
{
template <class _Tuple0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
operator()(tuple<_Types...> __t, _Tuple0&& __t0)
{
return _VSTD::forward_as_tuple(
_VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
_VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
}
template <class _Tuple0, class _Tuple1, class ..._Tuples>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
{
typedef _LIBCPP_NODEBUG typename remove_reference<_Tuple0>::type _T0;
typedef _LIBCPP_NODEBUG typename remove_reference<_Tuple1>::type _T1;
return __tuple_cat<
tuple<_Types...,
typename __apply_cv<_Tuple0, typename tuple_element<
_J0, _T0>::type>::type&&...>,
typename __make_tuple_indices<sizeof...(_Types) +
tuple_size<_T0>::value>::type,
typename __make_tuple_indices<tuple_size<_T1>::value>::type>()(
_VSTD::forward_as_tuple(
_VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
_VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...),
_VSTD::forward<_Tuple1>(__t1), _VSTD::forward<_Tuples>(__tpls)...);
}
};
template <class _Tuple0, class... _Tuples>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
typename __tuple_cat_return<_Tuple0, _Tuples...>::type
tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
{
typedef _LIBCPP_NODEBUG typename remove_reference<_Tuple0>::type _T0;
return __tuple_cat<tuple<>, __tuple_indices<>,
typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
(tuple<>(), _VSTD::forward<_Tuple0>(__t0),
_VSTD::forward<_Tuples>(__tpls)...);
}
template <class ..._Tp, class _Alloc>
struct _LIBCPP_TEMPLATE_VIS uses_allocator<tuple<_Tp...>, _Alloc>
: true_type {};
template <class _T1, class _T2>
template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
pair<_T1, _T2>::pair(piecewise_construct_t,
tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
__tuple_indices<_I1...>, __tuple_indices<_I2...>)
: first(_VSTD::forward<_Args1>(_VSTD::get<_I1>( __first_args))...),
second(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...)
{
}
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
#define _LIBCPP_NOEXCEPT_RETURN(...) noexcept(noexcept(__VA_ARGS__)) { return __VA_ARGS__; }
template <class _Fn, class _Tuple, size_t ..._Id>
inline _LIBCPP_INLINE_VISIBILITY
constexpr decltype(auto) __apply_tuple_impl(_Fn && __f, _Tuple && __t,
__tuple_indices<_Id...>)
_LIBCPP_NOEXCEPT_RETURN(
_VSTD::__invoke_constexpr(
_VSTD::forward<_Fn>(__f),
_VSTD::get<_Id>(_VSTD::forward<_Tuple>(__t))...)
)
template <class _Fn, class _Tuple>
inline _LIBCPP_INLINE_VISIBILITY
constexpr decltype(auto) apply(_Fn && __f, _Tuple && __t)
_LIBCPP_NOEXCEPT_RETURN(
_VSTD::__apply_tuple_impl(
_VSTD::forward<_Fn>(__f), _VSTD::forward<_Tuple>(__t),
typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{})
)
template <class _Tp, class _Tuple, size_t... _Idx>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _Tp __make_from_tuple_impl(_Tuple&& __t, __tuple_indices<_Idx...>)
_LIBCPP_NOEXCEPT_RETURN(
_Tp(_VSTD::get<_Idx>(_VSTD::forward<_Tuple>(__t))...)
)
template <class _Tp, class _Tuple>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _Tp make_from_tuple(_Tuple&& __t)
_LIBCPP_NOEXCEPT_RETURN(
_VSTD::__make_from_tuple_impl<_Tp>(_VSTD::forward<_Tuple>(__t),
typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{})
)
#undef _LIBCPP_NOEXCEPT_RETURN
#endif // _LIBCPP_STD_VER > 14
#endif // !defined(_LIBCPP_CXX03_LANG)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_TUPLE
diff --git a/contrib/llvm-project/libcxx/include/type_traits b/contrib/llvm-project/libcxx/include/type_traits
index b4010851f133..3391999675a0 100644
--- a/contrib/llvm-project/libcxx/include/type_traits
+++ b/contrib/llvm-project/libcxx/include/type_traits
@@ -1,4155 +1,4155 @@
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_TYPE_TRAITS
#define _LIBCPP_TYPE_TRAITS
/*
type_traits synopsis
namespace std
{
// helper class:
template <class T, T v> struct integral_constant;
typedef integral_constant<bool, true> true_type; // C++11
typedef integral_constant<bool, false> false_type; // C++11
template <bool B> // C++14
using bool_constant = integral_constant<bool, B>; // C++14
typedef bool_constant<true> true_type; // C++14
typedef bool_constant<false> false_type; // C++14
// helper traits
template <bool, class T = void> struct enable_if;
template <bool, class T, class F> struct conditional;
// Primary classification traits:
template <class T> struct is_void;
template <class T> struct is_null_pointer; // C++14
template <class T> struct is_integral;
template <class T> struct is_floating_point;
template <class T> struct is_array;
template <class T> struct is_pointer;
template <class T> struct is_lvalue_reference;
template <class T> struct is_rvalue_reference;
template <class T> struct is_member_object_pointer;
template <class T> struct is_member_function_pointer;
template <class T> struct is_enum;
template <class T> struct is_union;
template <class T> struct is_class;
template <class T> struct is_function;
// Secondary classification traits:
template <class T> struct is_reference;
template <class T> struct is_arithmetic;
template <class T> struct is_fundamental;
template <class T> struct is_member_pointer;
template <class T> struct is_scoped_enum; // C++2b
template <class T> struct is_scalar;
template <class T> struct is_object;
template <class T> struct is_compound;
// Const-volatile properties and transformations:
template <class T> struct is_const;
template <class T> struct is_volatile;
template <class T> struct remove_const;
template <class T> struct remove_volatile;
template <class T> struct remove_cv;
template <class T> struct add_const;
template <class T> struct add_volatile;
template <class T> struct add_cv;
// Reference transformations:
template <class T> struct remove_reference;
template <class T> struct add_lvalue_reference;
template <class T> struct add_rvalue_reference;
// Pointer transformations:
template <class T> struct remove_pointer;
template <class T> struct add_pointer;
template<class T> struct type_identity; // C++20
template<class T>
using type_identity_t = typename type_identity<T>::type; // C++20
// Integral properties:
template <class T> struct is_signed;
template <class T> struct is_unsigned;
template <class T> struct make_signed;
template <class T> struct make_unsigned;
// Array properties and transformations:
template <class T> struct rank;
template <class T, unsigned I = 0> struct extent;
template <class T> struct remove_extent;
template <class T> struct remove_all_extents;
template <class T> struct is_bounded_array; // C++20
template <class T> struct is_unbounded_array; // C++20
// Member introspection:
template <class T> struct is_pod;
template <class T> struct is_trivial;
template <class T> struct is_trivially_copyable;
template <class T> struct is_standard_layout;
template <class T> struct is_literal_type; // Deprecated in C++17; removed in C++20
template <class T> struct is_empty;
template <class T> struct is_polymorphic;
template <class T> struct is_abstract;
template <class T> struct is_final; // C++14
template <class T> struct is_aggregate; // C++17
template <class T, class... Args> struct is_constructible;
template <class T> struct is_default_constructible;
template <class T> struct is_copy_constructible;
template <class T> struct is_move_constructible;
template <class T, class U> struct is_assignable;
template <class T> struct is_copy_assignable;
template <class T> struct is_move_assignable;
template <class T, class U> struct is_swappable_with; // C++17
template <class T> struct is_swappable; // C++17
template <class T> struct is_destructible;
template <class T, class... Args> struct is_trivially_constructible;
template <class T> struct is_trivially_default_constructible;
template <class T> struct is_trivially_copy_constructible;
template <class T> struct is_trivially_move_constructible;
template <class T, class U> struct is_trivially_assignable;
template <class T> struct is_trivially_copy_assignable;
template <class T> struct is_trivially_move_assignable;
template <class T> struct is_trivially_destructible;
template <class T, class... Args> struct is_nothrow_constructible;
template <class T> struct is_nothrow_default_constructible;
template <class T> struct is_nothrow_copy_constructible;
template <class T> struct is_nothrow_move_constructible;
template <class T, class U> struct is_nothrow_assignable;
template <class T> struct is_nothrow_copy_assignable;
template <class T> struct is_nothrow_move_assignable;
template <class T, class U> struct is_nothrow_swappable_with; // C++17
template <class T> struct is_nothrow_swappable; // C++17
template <class T> struct is_nothrow_destructible;
template <class T> struct has_virtual_destructor;
template<class T> struct has_unique_object_representations; // C++17
// Relationships between types:
template <class T, class U> struct is_same;
template <class Base, class Derived> struct is_base_of;
template <class From, class To> struct is_convertible;
template <typename From, typename To> struct is_nothrow_convertible; // C++20
template <typename From, typename To> inline constexpr bool is_nothrow_convertible_v; // C++20
template <class Fn, class... ArgTypes> struct is_invocable;
template <class R, class Fn, class... ArgTypes> struct is_invocable_r;
template <class Fn, class... ArgTypes> struct is_nothrow_invocable;
template <class R, class Fn, class... ArgTypes> struct is_nothrow_invocable_r;
// Alignment properties and transformations:
template <class T> struct alignment_of;
template <size_t Len, size_t Align = most_stringent_alignment_requirement>
struct aligned_storage;
template <size_t Len, class... Types> struct aligned_union;
template <class T> struct remove_cvref; // C++20
template <class T> struct decay;
template <class... T> struct common_type;
template <class T> struct underlying_type;
template <class> class result_of; // undefined; deprecated in C++17; removed in C++20
template <class Fn, class... ArgTypes> class result_of<Fn(ArgTypes...)>; // deprecated in C++17; removed in C++20
template <class Fn, class... ArgTypes> struct invoke_result; // C++17
// const-volatile modifications:
template <class T>
using remove_const_t = typename remove_const<T>::type; // C++14
template <class T>
using remove_volatile_t = typename remove_volatile<T>::type; // C++14
template <class T>
using remove_cv_t = typename remove_cv<T>::type; // C++14
template <class T>
using add_const_t = typename add_const<T>::type; // C++14
template <class T>
using add_volatile_t = typename add_volatile<T>::type; // C++14
template <class T>
using add_cv_t = typename add_cv<T>::type; // C++14
// reference modifications:
template <class T>
using remove_reference_t = typename remove_reference<T>::type; // C++14
template <class T>
using add_lvalue_reference_t = typename add_lvalue_reference<T>::type; // C++14
template <class T>
using add_rvalue_reference_t = typename add_rvalue_reference<T>::type; // C++14
// sign modifications:
template <class T>
using make_signed_t = typename make_signed<T>::type; // C++14
template <class T>
using make_unsigned_t = typename make_unsigned<T>::type; // C++14
// array modifications:
template <class T>
using remove_extent_t = typename remove_extent<T>::type; // C++14
template <class T>
using remove_all_extents_t = typename remove_all_extents<T>::type; // C++14
template <class T>
inline constexpr bool is_bounded_array_v
= is_bounded_array<T>::value; // C++20
inline constexpr bool is_unbounded_array_v
= is_unbounded_array<T>::value; // C++20
// pointer modifications:
template <class T>
using remove_pointer_t = typename remove_pointer<T>::type; // C++14
template <class T>
using add_pointer_t = typename add_pointer<T>::type; // C++14
// other transformations:
template <size_t Len, size_t Align=default-alignment>
using aligned_storage_t = typename aligned_storage<Len,Align>::type; // C++14
template <size_t Len, class... Types>
using aligned_union_t = typename aligned_union<Len,Types...>::type; // C++14
template <class T>
using remove_cvref_t = typename remove_cvref<T>::type; // C++20
template <class T>
using decay_t = typename decay<T>::type; // C++14
template <bool b, class T=void>
using enable_if_t = typename enable_if<b,T>::type; // C++14
template <bool b, class T, class F>
using conditional_t = typename conditional<b,T,F>::type; // C++14
template <class... T>
using common_type_t = typename common_type<T...>::type; // C++14
template <class T>
using underlying_type_t = typename underlying_type<T>::type; // C++14
template <class T>
using result_of_t = typename result_of<T>::type; // C++14; deprecated in C++17; removed in C++20
template <class Fn, class... ArgTypes>
using invoke_result_t = typename invoke_result<Fn, ArgTypes...>::type; // C++17
template <class...>
using void_t = void; // C++17
// See C++14 20.10.4.1, primary type categories
template <class T> inline constexpr bool is_void_v
= is_void<T>::value; // C++17
template <class T> inline constexpr bool is_null_pointer_v
= is_null_pointer<T>::value; // C++17
template <class T> inline constexpr bool is_integral_v
= is_integral<T>::value; // C++17
template <class T> inline constexpr bool is_floating_point_v
= is_floating_point<T>::value; // C++17
template <class T> inline constexpr bool is_array_v
= is_array<T>::value; // C++17
template <class T> inline constexpr bool is_pointer_v
= is_pointer<T>::value; // C++17
template <class T> inline constexpr bool is_lvalue_reference_v
= is_lvalue_reference<T>::value; // C++17
template <class T> inline constexpr bool is_rvalue_reference_v
= is_rvalue_reference<T>::value; // C++17
template <class T> inline constexpr bool is_member_object_pointer_v
= is_member_object_pointer<T>::value; // C++17
template <class T> inline constexpr bool is_member_function_pointer_v
= is_member_function_pointer<T>::value; // C++17
template <class T> inline constexpr bool is_enum_v
= is_enum<T>::value; // C++17
template <class T> inline constexpr bool is_union_v
= is_union<T>::value; // C++17
template <class T> inline constexpr bool is_class_v
= is_class<T>::value; // C++17
template <class T> inline constexpr bool is_function_v
= is_function<T>::value; // C++17
// See C++14 20.10.4.2, composite type categories
template <class T> inline constexpr bool is_reference_v
= is_reference<T>::value; // C++17
template <class T> inline constexpr bool is_arithmetic_v
= is_arithmetic<T>::value; // C++17
template <class T> inline constexpr bool is_fundamental_v
= is_fundamental<T>::value; // C++17
template <class T> inline constexpr bool is_object_v
= is_object<T>::value; // C++17
template <class T> inline constexpr bool is_scalar_v
= is_scalar<T>::value; // C++17
template <class T> inline constexpr bool is_compound_v
= is_compound<T>::value; // C++17
template <class T> inline constexpr bool is_member_pointer_v
= is_member_pointer<T>::value; // C++17
template <class T> inline constexpr bool is_scoped_enum_v
= is_scoped_enum<T>::value; // C++2b
// See C++14 20.10.4.3, type properties
template <class T> inline constexpr bool is_const_v
= is_const<T>::value; // C++17
template <class T> inline constexpr bool is_volatile_v
= is_volatile<T>::value; // C++17
template <class T> inline constexpr bool is_trivial_v
= is_trivial<T>::value; // C++17
template <class T> inline constexpr bool is_trivially_copyable_v
= is_trivially_copyable<T>::value; // C++17
template <class T> inline constexpr bool is_standard_layout_v
= is_standard_layout<T>::value; // C++17
template <class T> inline constexpr bool is_pod_v
= is_pod<T>::value; // C++17
template <class T> inline constexpr bool is_literal_type_v
= is_literal_type<T>::value; // C++17; deprecated in C++17; removed in C++20
template <class T> inline constexpr bool is_empty_v
= is_empty<T>::value; // C++17
template <class T> inline constexpr bool is_polymorphic_v
= is_polymorphic<T>::value; // C++17
template <class T> inline constexpr bool is_abstract_v
= is_abstract<T>::value; // C++17
template <class T> inline constexpr bool is_final_v
= is_final<T>::value; // C++17
template <class T> inline constexpr bool is_aggregate_v
= is_aggregate<T>::value; // C++17
template <class T> inline constexpr bool is_signed_v
= is_signed<T>::value; // C++17
template <class T> inline constexpr bool is_unsigned_v
= is_unsigned<T>::value; // C++17
template <class T, class... Args> inline constexpr bool is_constructible_v
= is_constructible<T, Args...>::value; // C++17
template <class T> inline constexpr bool is_default_constructible_v
= is_default_constructible<T>::value; // C++17
template <class T> inline constexpr bool is_copy_constructible_v
= is_copy_constructible<T>::value; // C++17
template <class T> inline constexpr bool is_move_constructible_v
= is_move_constructible<T>::value; // C++17
template <class T, class U> inline constexpr bool is_assignable_v
= is_assignable<T, U>::value; // C++17
template <class T> inline constexpr bool is_copy_assignable_v
= is_copy_assignable<T>::value; // C++17
template <class T> inline constexpr bool is_move_assignable_v
= is_move_assignable<T>::value; // C++17
template <class T, class U> inline constexpr bool is_swappable_with_v
= is_swappable_with<T, U>::value; // C++17
template <class T> inline constexpr bool is_swappable_v
= is_swappable<T>::value; // C++17
template <class T> inline constexpr bool is_destructible_v
= is_destructible<T>::value; // C++17
template <class T, class... Args> inline constexpr bool is_trivially_constructible_v
= is_trivially_constructible<T, Args...>::value; // C++17
template <class T> inline constexpr bool is_trivially_default_constructible_v
= is_trivially_default_constructible<T>::value; // C++17
template <class T> inline constexpr bool is_trivially_copy_constructible_v
= is_trivially_copy_constructible<T>::value; // C++17
template <class T> inline constexpr bool is_trivially_move_constructible_v
= is_trivially_move_constructible<T>::value; // C++17
template <class T, class U> inline constexpr bool is_trivially_assignable_v
= is_trivially_assignable<T, U>::value; // C++17
template <class T> inline constexpr bool is_trivially_copy_assignable_v
= is_trivially_copy_assignable<T>::value; // C++17
template <class T> inline constexpr bool is_trivially_move_assignable_v
= is_trivially_move_assignable<T>::value; // C++17
template <class T> inline constexpr bool is_trivially_destructible_v
= is_trivially_destructible<T>::value; // C++17
template <class T, class... Args> inline constexpr bool is_nothrow_constructible_v
= is_nothrow_constructible<T, Args...>::value; // C++17
template <class T> inline constexpr bool is_nothrow_default_constructible_v
= is_nothrow_default_constructible<T>::value; // C++17
template <class T> inline constexpr bool is_nothrow_copy_constructible_v
= is_nothrow_copy_constructible<T>::value; // C++17
template <class T> inline constexpr bool is_nothrow_move_constructible_v
= is_nothrow_move_constructible<T>::value; // C++17
template <class T, class U> inline constexpr bool is_nothrow_assignable_v
= is_nothrow_assignable<T, U>::value; // C++17
template <class T> inline constexpr bool is_nothrow_copy_assignable_v
= is_nothrow_copy_assignable<T>::value; // C++17
template <class T> inline constexpr bool is_nothrow_move_assignable_v
= is_nothrow_move_assignable<T>::value; // C++17
template <class T, class U> inline constexpr bool is_nothrow_swappable_with_v
= is_nothrow_swappable_with<T, U>::value; // C++17
template <class T> inline constexpr bool is_nothrow_swappable_v
= is_nothrow_swappable<T>::value; // C++17
template <class T> inline constexpr bool is_nothrow_destructible_v
= is_nothrow_destructible<T>::value; // C++17
template <class T> inline constexpr bool has_virtual_destructor_v
= has_virtual_destructor<T>::value; // C++17
template<class T> inline constexpr bool has_unique_object_representations_v // C++17
= has_unique_object_representations<T>::value;
// See C++14 20.10.5, type property queries
template <class T> inline constexpr size_t alignment_of_v
= alignment_of<T>::value; // C++17
template <class T> inline constexpr size_t rank_v
= rank<T>::value; // C++17
template <class T, unsigned I = 0> inline constexpr size_t extent_v
= extent<T, I>::value; // C++17
// See C++14 20.10.6, type relations
template <class T, class U> inline constexpr bool is_same_v
= is_same<T, U>::value; // C++17
template <class Base, class Derived> inline constexpr bool is_base_of_v
= is_base_of<Base, Derived>::value; // C++17
template <class From, class To> inline constexpr bool is_convertible_v
= is_convertible<From, To>::value; // C++17
template <class Fn, class... ArgTypes> inline constexpr bool is_invocable_v
= is_invocable<Fn, ArgTypes...>::value; // C++17
template <class R, class Fn, class... ArgTypes> inline constexpr bool is_invocable_r_v
= is_invocable_r<R, Fn, ArgTypes...>::value; // C++17
template <class Fn, class... ArgTypes> inline constexpr bool is_nothrow_invocable_v
= is_nothrow_invocable<Fn, ArgTypes...>::value; // C++17
template <class R, class Fn, class... ArgTypes> inline constexpr bool is_nothrow_invocable_r_v
= is_nothrow_invocable_r<R, Fn, ArgTypes...>::value; // C++17
// [meta.logical], logical operator traits:
template<class... B> struct conjunction; // C++17
template<class... B>
inline constexpr bool conjunction_v = conjunction<B...>::value; // C++17
template<class... B> struct disjunction; // C++17
template<class... B>
inline constexpr bool disjunction_v = disjunction<B...>::value; // C++17
template<class B> struct negation; // C++17
template<class B>
inline constexpr bool negation_v = negation<B>::value; // C++17
}
*/
#include <__config>
#include <cstddef>
#include <version>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS pair;
template <class _Tp> class _LIBCPP_TEMPLATE_VIS reference_wrapper;
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash;
template <class _Tp, _Tp __v>
struct _LIBCPP_TEMPLATE_VIS integral_constant
{
static _LIBCPP_CONSTEXPR const _Tp value = __v;
typedef _Tp value_type;
typedef integral_constant type;
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR operator value_type() const _NOEXCEPT {return value;}
#if _LIBCPP_STD_VER > 11
_LIBCPP_INLINE_VISIBILITY
constexpr value_type operator ()() const _NOEXCEPT {return value;}
#endif
};
template <class _Tp, _Tp __v>
_LIBCPP_CONSTEXPR const _Tp integral_constant<_Tp, __v>::value;
#if _LIBCPP_STD_VER > 14
template <bool __b>
using bool_constant = integral_constant<bool, __b>;
#define _LIBCPP_BOOL_CONSTANT(__b) bool_constant<(__b)>
#else
#define _LIBCPP_BOOL_CONSTANT(__b) integral_constant<bool,(__b)>
#endif
template <bool, class _Tp = void> struct _LIBCPP_TEMPLATE_VIS enable_if {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS enable_if<true, _Tp> {typedef _Tp type;};
template <bool _Bp, class _Tp = void> using __enable_if_t _LIBCPP_NODEBUG = typename enable_if<_Bp, _Tp>::type;
#if _LIBCPP_STD_VER > 11
template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp, _Tp>::type;
#endif
typedef _LIBCPP_BOOL_CONSTANT(true) true_type;
typedef _LIBCPP_BOOL_CONSTANT(false) false_type;
template <bool _Val>
using _BoolConstant _LIBCPP_NODEBUG = integral_constant<bool, _Val>;
template <bool> struct _MetaBase;
template <>
struct _MetaBase<true> {
template <class _Tp, class _Up>
using _SelectImpl _LIBCPP_NODEBUG = _Tp;
template <template <class...> class _FirstFn, template <class...> class, class ..._Args>
using _SelectApplyImpl _LIBCPP_NODEBUG = _FirstFn<_Args...>;
template <class _First, class...>
using _FirstImpl _LIBCPP_NODEBUG = _First;
template <class, class _Second, class...>
using _SecondImpl _LIBCPP_NODEBUG = _Second;
template <class _Result, class _First, class ..._Rest>
using _OrImpl _LIBCPP_NODEBUG = typename _MetaBase<_First::value != true && sizeof...(_Rest) != 0>::template _OrImpl<_First, _Rest...>;
};
template <>
struct _MetaBase<false> {
template <class _Tp, class _Up>
using _SelectImpl _LIBCPP_NODEBUG = _Up;
template <template <class...> class, template <class...> class _SecondFn, class ..._Args>
using _SelectApplyImpl _LIBCPP_NODEBUG = _SecondFn<_Args...>;
template <class _Result, class ...>
using _OrImpl _LIBCPP_NODEBUG = _Result;
};
template <bool _Cond, class _IfRes, class _ElseRes>
using _If _LIBCPP_NODEBUG = typename _MetaBase<_Cond>::template _SelectImpl<_IfRes, _ElseRes>;
template <class ..._Rest>
using _Or _LIBCPP_NODEBUG = typename _MetaBase< sizeof...(_Rest) != 0 >::template _OrImpl<false_type, _Rest...>;
template <class _Pred>
struct _Not : _BoolConstant<!_Pred::value> {};
template <class ..._Args>
using _FirstType _LIBCPP_NODEBUG = typename _MetaBase<(sizeof...(_Args) >= 1)>::template _FirstImpl<_Args...>;
template <class ..._Args>
using _SecondType _LIBCPP_NODEBUG = typename _MetaBase<(sizeof...(_Args) >= 2)>::template _SecondImpl<_Args...>;
template <class ...> using __expand_to_true = true_type;
template <class ..._Pred>
__expand_to_true<__enable_if_t<_Pred::value>...> __and_helper(int);
template <class ...>
false_type __and_helper(...);
template <class ..._Pred>
using _And _LIBCPP_NODEBUG = decltype(__and_helper<_Pred...>(0));
template <template <class...> class _Func, class ..._Args>
struct _Lazy : _Func<_Args...> {};
// Member detector base
template <template <class...> class _Templ, class ..._Args, class = _Templ<_Args...> >
true_type __sfinae_test_impl(int);
template <template <class...> class, class ...>
false_type __sfinae_test_impl(...);
template <template <class ...> class _Templ, class ..._Args>
using _IsValidExpansion _LIBCPP_NODEBUG = decltype(__sfinae_test_impl<_Templ, _Args...>(0));
template <class>
struct __void_t { typedef void type; };
template <class _Tp>
struct __identity { typedef _Tp type; };
template <class _Tp>
using __identity_t _LIBCPP_NODEBUG = typename __identity<_Tp>::type;
template <class _Tp, bool>
struct _LIBCPP_TEMPLATE_VIS __dependent_type : public _Tp {};
template <bool _Bp, class _If, class _Then>
struct _LIBCPP_TEMPLATE_VIS conditional {typedef _If type;};
template <class _If, class _Then>
struct _LIBCPP_TEMPLATE_VIS conditional<false, _If, _Then> {typedef _Then type;};
#if _LIBCPP_STD_VER > 11
template <bool _Bp, class _If, class _Then> using conditional_t = typename conditional<_Bp, _If, _Then>::type;
#endif
// is_same
template <class _Tp, class _Up>
struct _LIBCPP_TEMPLATE_VIS is_same : _BoolConstant<__is_same(_Tp, _Up)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp, class _Up>
inline constexpr bool is_same_v = __is_same(_Tp, _Up);
#endif
// _IsSame<T,U> has the same effect as is_same<T,U> but instantiates fewer types:
// is_same<A,B> and is_same<C,D> are guaranteed to be different types, but
// _IsSame<A,B> and _IsSame<C,D> are the same type (namely, false_type).
// Neither GCC nor Clang can mangle the __is_same builtin, so _IsSame
// mustn't be directly used anywhere that contributes to name-mangling
// (such as in a dependent return type).
template <class _Tp, class _Up>
using _IsSame = _BoolConstant<__is_same(_Tp, _Up)>;
template <class _Tp, class _Up>
using _IsNotSame = _BoolConstant<!__is_same(_Tp, _Up)>;
template <class _Tp>
using __test_for_primary_template = __enable_if_t<
_IsSame<_Tp, typename _Tp::__primary_template>::value
>;
template <class _Tp>
using __is_primary_template = _IsValidExpansion<
__test_for_primary_template, _Tp
>;
// helper class
struct __two {char __lx[2];};
// is_const
#if __has_keyword(__is_const)
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_const : _BoolConstant<__is_const(_Tp)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_const_v = __is_const(_Tp);
#endif
#else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const<_Tp const> : public true_type {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_const_v = is_const<_Tp>::value;
#endif
#endif // __has_keyword(__is_const)
// is_volatile
#if __has_keyword(__is_volatile)
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_volatile : _BoolConstant<__is_volatile(_Tp)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_volatile_v = __is_volatile(_Tp);
#endif
#else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile<_Tp volatile> : public true_type {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_volatile_v = is_volatile<_Tp>::value;
#endif
#endif // __has_keyword(__is_volatile)
// remove_const
#if __has_keyword(__remove_const)
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS remove_const {typedef __remove_const(_Tp) type;};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using remove_const_t = __remove_const(_Tp);
#endif
#else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const {typedef _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const<const _Tp> {typedef _Tp type;};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using remove_const_t = typename remove_const<_Tp>::type;
#endif
#endif // __has_keyword(__remove_const)
// remove_volatile
#if __has_keyword(__remove_volatile)
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS remove_volatile {typedef __remove_volatile(_Tp) type;};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using remove_volatile_t = __remove_volatile(_Tp);
#endif
#else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile {typedef _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile<volatile _Tp> {typedef _Tp type;};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using remove_volatile_t = typename remove_volatile<_Tp>::type;
#endif
#endif // __has_keyword(__remove_volatile)
// remove_cv
#if __has_keyword(__remove_cv)
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS remove_cv {typedef __remove_cv(_Tp) type;};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using remove_cv_t = __remove_cv(_Tp);
#endif
#else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_cv
{typedef typename remove_volatile<typename remove_const<_Tp>::type>::type type;};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using remove_cv_t = typename remove_cv<_Tp>::type;
#endif
#endif // __has_keyword(__remove_cv)
// is_void
#if __has_keyword(__is_void)
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_void : _BoolConstant<__is_void(_Tp)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_void_v = __is_void(_Tp);
#endif
#else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_void
: public is_same<typename remove_cv<_Tp>::type, void> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_void_v = is_void<_Tp>::value;
#endif
#endif // __has_keyword(__is_void)
// __is_nullptr_t
template <class _Tp> struct __is_nullptr_t_impl : public false_type {};
template <> struct __is_nullptr_t_impl<nullptr_t> : public true_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS __is_nullptr_t
: public __is_nullptr_t_impl<typename remove_cv<_Tp>::type> {};
#if _LIBCPP_STD_VER > 11
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_null_pointer
: public __is_nullptr_t_impl<typename remove_cv<_Tp>::type> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value;
#endif
#endif // _LIBCPP_STD_VER > 11
// is_integral
#if __has_keyword(__is_integral)
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_integral : _BoolConstant<__is_integral(_Tp)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_integral_v = __is_integral(_Tp);
#endif
#else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_integral
: public _BoolConstant<__libcpp_is_integral<typename remove_cv<_Tp>::type>::value> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_integral_v = is_integral<_Tp>::value;
#endif
#endif // __has_keyword(__is_integral)
// [basic.fundamental] defines five standard signed integer types;
// __int128_t is an extended signed integer type.
// The signed and unsigned integer types, plus bool and the
// five types with "char" in their name, compose the "integral" types.
template <class _Tp> struct __libcpp_is_signed_integer : public false_type {};
template <> struct __libcpp_is_signed_integer<signed char> : public true_type {};
template <> struct __libcpp_is_signed_integer<signed short> : public true_type {};
template <> struct __libcpp_is_signed_integer<signed int> : public true_type {};
template <> struct __libcpp_is_signed_integer<signed long> : public true_type {};
template <> struct __libcpp_is_signed_integer<signed long long> : public true_type {};
#ifndef _LIBCPP_HAS_NO_INT128
template <> struct __libcpp_is_signed_integer<__int128_t> : public true_type {};
#endif
template <class _Tp> struct __libcpp_is_unsigned_integer : public false_type {};
template <> struct __libcpp_is_unsigned_integer<unsigned char> : public true_type {};
template <> struct __libcpp_is_unsigned_integer<unsigned short> : public true_type {};
template <> struct __libcpp_is_unsigned_integer<unsigned int> : public true_type {};
template <> struct __libcpp_is_unsigned_integer<unsigned long> : public true_type {};
template <> struct __libcpp_is_unsigned_integer<unsigned long long> : public true_type {};
#ifndef _LIBCPP_HAS_NO_INT128
template <> struct __libcpp_is_unsigned_integer<__uint128_t> : public true_type {};
#endif
// is_floating_point
// <concepts> implements __libcpp_floating_point
template <class _Tp> struct __libcpp_is_floating_point : public false_type {};
template <> struct __libcpp_is_floating_point<float> : public true_type {};
template <> struct __libcpp_is_floating_point<double> : public true_type {};
template <> struct __libcpp_is_floating_point<long double> : public true_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_floating_point
: public __libcpp_is_floating_point<typename remove_cv<_Tp>::type> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value;
#endif
// is_array
#if __has_keyword(__is_array)
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_array : _BoolConstant<__is_array(_Tp)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_array_v = __is_array(_Tp);
#endif
#else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array
: public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[]>
: public true_type {};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[_Np]>
: public true_type {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_array_v = is_array<_Tp>::value;
#endif
#endif // __has_keyword(__is_array)
// is_pointer
// Before AppleClang 12.0.5, __is_pointer didn't work for Objective-C types.
#if __has_keyword(__is_pointer) && \
!(defined(_LIBCPP_APPLE_CLANG_VER) && _LIBCPP_APPLE_CLANG_VER < 1205)
template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_pointer : _BoolConstant<__is_pointer(_Tp)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_pointer_v = __is_pointer(_Tp);
#endif
#else // __has_keyword(__is_pointer)
template <class _Tp> struct __libcpp_is_pointer : public false_type {};
template <class _Tp> struct __libcpp_is_pointer<_Tp*> : public true_type {};
template <class _Tp> struct __libcpp_remove_objc_qualifiers { typedef _Tp type; };
#if defined(_LIBCPP_HAS_OBJC_ARC)
template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __strong> { typedef _Tp type; };
template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __weak> { typedef _Tp type; };
template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __autoreleasing> { typedef _Tp type; };
template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __unsafe_unretained> { typedef _Tp type; };
#endif
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pointer
: public __libcpp_is_pointer<typename __libcpp_remove_objc_qualifiers<typename remove_cv<_Tp>::type>::type> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_pointer_v = is_pointer<_Tp>::value;
#endif
#endif // __has_keyword(__is_pointer)
// is_reference
#if __has_keyword(__is_lvalue_reference) && \
__has_keyword(__is_rvalue_reference) && \
__has_keyword(__is_reference)
template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference : _BoolConstant<__is_lvalue_reference(_Tp)> { };
template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference : _BoolConstant<__is_rvalue_reference(_Tp)> { };
template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_reference : _BoolConstant<__is_reference(_Tp)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_reference_v = __is_reference(_Tp);
template <class _Tp>
inline constexpr bool is_lvalue_reference_v = __is_lvalue_reference(_Tp);
template <class _Tp>
inline constexpr bool is_rvalue_reference_v = __is_rvalue_reference(_Tp);
#endif
#else // __has_keyword(__is_lvalue_reference) && etc...
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference<_Tp&> : public true_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference<_Tp&&> : public true_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference<_Tp&> : public true_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference<_Tp&&> : public true_type {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_reference_v = is_reference<_Tp>::value;
template <class _Tp>
inline constexpr bool is_lvalue_reference_v = is_lvalue_reference<_Tp>::value;
template <class _Tp>
inline constexpr bool is_rvalue_reference_v = is_rvalue_reference<_Tp>::value;
#endif
#endif // __has_keyword(__is_lvalue_reference) && etc...
// is_union
#if __has_feature(is_union) || defined(_LIBCPP_COMPILER_GCC)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_union
: public integral_constant<bool, __is_union(_Tp)> {};
#else
template <class _Tp> struct __libcpp_union : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_union
: public __libcpp_union<typename remove_cv<_Tp>::type> {};
#endif
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_union_v = is_union<_Tp>::value;
#endif
// is_class
#if __has_feature(is_class) || defined(_LIBCPP_COMPILER_GCC)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_class
: public integral_constant<bool, __is_class(_Tp)> {};
#else
namespace __is_class_imp
{
template <class _Tp> char __test(int _Tp::*);
template <class _Tp> __two __test(...);
}
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_class
: public integral_constant<bool, sizeof(__is_class_imp::__test<_Tp>(0)) == 1 && !is_union<_Tp>::value> {};
#endif
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_class_v = is_class<_Tp>::value;
#endif
// is_function
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_function
: public _BoolConstant<
#ifdef __clang__
__is_function(_Tp)
#else
!(is_reference<_Tp>::value || is_const<const _Tp>::value)
#endif
> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_function_v = is_function<_Tp>::value;
#endif
template <class _Tp> struct __libcpp_is_member_pointer {
enum {
__is_member = false,
__is_func = false,
__is_obj = false
};
};
template <class _Tp, class _Up> struct __libcpp_is_member_pointer<_Tp _Up::*> {
enum {
__is_member = true,
__is_func = is_function<_Tp>::value,
__is_obj = !__is_func,
};
};
#if __has_keyword(__is_member_function_pointer)
template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer
: _BoolConstant<__is_member_function_pointer(_Tp)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_member_function_pointer_v = __is_member_function_pointer(_Tp);
#endif
#else // __has_keyword(__is_member_function_pointer)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer
: public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_func > {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_member_function_pointer_v = is_member_function_pointer<_Tp>::value;
#endif
#endif // __has_keyword(__is_member_function_pointer)
// is_member_pointer
#if __has_keyword(__is_member_pointer)
template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_member_pointer : _BoolConstant<__is_member_pointer(_Tp)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_member_pointer_v = __is_member_pointer(_Tp);
#endif
#else // __has_keyword(__is_member_pointer)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_pointer
: public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_member > {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value;
#endif
#endif // __has_keyword(__is_member_pointer)
// is_member_object_pointer
#if __has_keyword(__is_member_object_pointer)
template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer
: _BoolConstant<__is_member_object_pointer(_Tp)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_member_object_pointer_v = __is_member_object_pointer(_Tp);
#endif
#else // __has_keyword(__is_member_object_pointer)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer
: public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_obj > {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_member_object_pointer_v = is_member_object_pointer<_Tp>::value;
#endif
#endif // __has_keyword(__is_member_object_pointer)
// is_enum
#if __has_feature(is_enum) || defined(_LIBCPP_COMPILER_GCC)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum
: public integral_constant<bool, __is_enum(_Tp)> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_enum_v = __is_enum(_Tp);
#endif
#else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum
: public integral_constant<bool, !is_void<_Tp>::value &&
!is_integral<_Tp>::value &&
!is_floating_point<_Tp>::value &&
!is_array<_Tp>::value &&
!is_pointer<_Tp>::value &&
!is_reference<_Tp>::value &&
!is_member_pointer<_Tp>::value &&
!is_union<_Tp>::value &&
!is_class<_Tp>::value &&
!is_function<_Tp>::value > {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_enum_v = is_enum<_Tp>::value;
#endif
#endif // __has_feature(is_enum) || defined(_LIBCPP_COMPILER_GCC)
// is_arithmetic
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_arithmetic
: public integral_constant<bool, is_integral<_Tp>::value ||
is_floating_point<_Tp>::value> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value;
#endif
// is_fundamental
// Before Clang 10, __is_fundamental didn't work for nullptr_t.
// In C++03 nullptr_t is library-provided but must still count as "fundamental."
#if __has_keyword(__is_fundamental) && \
!(defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER < 1000) && \
!defined(_LIBCPP_CXX03_LANG)
template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_fundamental : _BoolConstant<__is_fundamental(_Tp)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_fundamental_v = __is_fundamental(_Tp);
#endif
#else // __has_keyword(__is_fundamental)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_fundamental
: public integral_constant<bool, is_void<_Tp>::value ||
__is_nullptr_t<_Tp>::value ||
is_arithmetic<_Tp>::value> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value;
#endif
#endif // __has_keyword(__is_fundamental)
// is_scalar
// In C++03 nullptr_t is library-provided but must still count as "scalar."
#if __has_keyword(__is_scalar) && !defined(_LIBCPP_CXX03_LANG)
template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_scalar : _BoolConstant<__is_scalar(_Tp)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_scalar_v = __is_scalar(_Tp);
#endif
#else // __has_keyword(__is_scalar)
template <class _Tp> struct __is_block : false_type {};
#if defined(_LIBCPP_HAS_EXTENSION_BLOCKS)
template <class _Rp, class ..._Args> struct __is_block<_Rp (^)(_Args...)> : true_type {};
#endif
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_scalar
: public integral_constant<bool, is_arithmetic<_Tp>::value ||
is_member_pointer<_Tp>::value ||
is_pointer<_Tp>::value ||
__is_nullptr_t<_Tp>::value ||
__is_block<_Tp>::value ||
is_enum<_Tp>::value > {};
template <> struct _LIBCPP_TEMPLATE_VIS is_scalar<nullptr_t> : public true_type {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_scalar_v = is_scalar<_Tp>::value;
#endif
#endif // __has_keyword(__is_scalar)
// is_object
#if __has_keyword(__is_object)
template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_object : _BoolConstant<__is_object(_Tp)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_object_v = __is_object(_Tp);
#endif
#else // __has_keyword(__is_object)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_object
: public integral_constant<bool, is_scalar<_Tp>::value ||
is_array<_Tp>::value ||
is_union<_Tp>::value ||
is_class<_Tp>::value > {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_object_v = is_object<_Tp>::value;
#endif
#endif // __has_keyword(__is_object)
// is_compound
// >= 11 because in C++03 nullptr isn't actually nullptr
#if __has_keyword(__is_compound) && !defined(_LIBCPP_CXX03_LANG)
template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_compound : _BoolConstant<__is_compound(_Tp)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_compound_v = __is_compound(_Tp);
#endif
#else // __has_keyword(__is_compound)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_compound
: public integral_constant<bool, !is_fundamental<_Tp>::value> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_compound_v = is_compound<_Tp>::value;
#endif
#endif // __has_keyword(__is_compound)
// __is_referenceable [defns.referenceable]
struct __is_referenceable_impl {
template <class _Tp> static _Tp& __test(int);
template <class _Tp> static __two __test(...);
};
template <class _Tp>
struct __is_referenceable : integral_constant<bool,
_IsNotSame<decltype(__is_referenceable_impl::__test<_Tp>(0)), __two>::value> {};
// add_const
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_const {
typedef _LIBCPP_NODEBUG const _Tp type;
};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using add_const_t = typename add_const<_Tp>::type;
#endif
// add_volatile
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_volatile {
typedef _LIBCPP_NODEBUG volatile _Tp type;
};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using add_volatile_t = typename add_volatile<_Tp>::type;
#endif
// add_cv
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_cv {
typedef _LIBCPP_NODEBUG const volatile _Tp type;
};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using add_cv_t = typename add_cv<_Tp>::type;
#endif
// remove_reference
#if __has_keyword(__remove_reference)
template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS remove_reference { typedef __remove_reference(_Tp) type; };
#else // __has_keyword(__remove_reference)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&> {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&&> {typedef _LIBCPP_NODEBUG _Tp type;};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using remove_reference_t = typename remove_reference<_Tp>::type;
#endif
#endif // __has_keyword(__remove_reference)
// add_lvalue_reference
template <class _Tp, bool = __is_referenceable<_Tp>::value> struct __add_lvalue_reference_impl { typedef _LIBCPP_NODEBUG _Tp type; };
template <class _Tp > struct __add_lvalue_reference_impl<_Tp, true> { typedef _LIBCPP_NODEBUG _Tp& type; };
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_lvalue_reference
{typedef _LIBCPP_NODEBUG typename __add_lvalue_reference_impl<_Tp>::type type;};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
#endif
template <class _Tp, bool = __is_referenceable<_Tp>::value> struct __add_rvalue_reference_impl { typedef _LIBCPP_NODEBUG _Tp type; };
template <class _Tp > struct __add_rvalue_reference_impl<_Tp, true> { typedef _LIBCPP_NODEBUG _Tp&& type; };
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_rvalue_reference
{typedef _LIBCPP_NODEBUG typename __add_rvalue_reference_impl<_Tp>::type type;};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
#endif
// Suppress deprecation notice for volatile-qualified return type resulting
// from volatile-qualified types _Tp.
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Tp> _Tp&& __declval(int);
template <class _Tp> _Tp __declval(long);
_LIBCPP_SUPPRESS_DEPRECATED_POP
template <class _Tp>
decltype(__declval<_Tp>(0))
declval() _NOEXCEPT;
// __uncvref
template <class _Tp>
struct __uncvref {
typedef _LIBCPP_NODEBUG typename remove_cv<typename remove_reference<_Tp>::type>::type type;
};
template <class _Tp>
struct __unconstref {
typedef _LIBCPP_NODEBUG typename remove_const<typename remove_reference<_Tp>::type>::type type;
};
#ifndef _LIBCPP_CXX03_LANG
template <class _Tp>
using __uncvref_t _LIBCPP_NODEBUG = typename __uncvref<_Tp>::type;
#endif
// __is_same_uncvref
template <class _Tp, class _Up>
struct __is_same_uncvref : _IsSame<typename __uncvref<_Tp>::type,
typename __uncvref<_Up>::type> {};
#if _LIBCPP_STD_VER > 17
// remove_cvref - same as __uncvref
template <class _Tp>
struct remove_cvref : public __uncvref<_Tp> {};
template <class _Tp> using remove_cvref_t = typename remove_cvref<_Tp>::type;
#endif
struct __any
{
__any(...);
};
// remove_pointer
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp*> {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const> {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* volatile> {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const volatile> {typedef _LIBCPP_NODEBUG _Tp type;};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using remove_pointer_t = typename remove_pointer<_Tp>::type;
#endif
// add_pointer
template <class _Tp,
bool = __is_referenceable<_Tp>::value ||
_IsSame<typename remove_cv<_Tp>::type, void>::value>
struct __add_pointer_impl
{typedef _LIBCPP_NODEBUG typename remove_reference<_Tp>::type* type;};
template <class _Tp> struct __add_pointer_impl<_Tp, false>
{typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_pointer
{typedef _LIBCPP_NODEBUG typename __add_pointer_impl<_Tp>::type type;};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using add_pointer_t = typename add_pointer<_Tp>::type;
#endif
// type_identity
#if _LIBCPP_STD_VER > 17
template<class _Tp> struct type_identity { typedef _Tp type; };
template<class _Tp> using type_identity_t = typename type_identity<_Tp>::type;
#endif
// is_signed
#if __has_keyword(__is_signed)
template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_signed : _BoolConstant<__is_signed(_Tp)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_signed_v = __is_signed(_Tp);
#endif
#else // __has_keyword(__is_signed)
template <class _Tp, bool = is_integral<_Tp>::value>
struct __libcpp_is_signed_impl : public _LIBCPP_BOOL_CONSTANT(_Tp(-1) < _Tp(0)) {};
template <class _Tp>
struct __libcpp_is_signed_impl<_Tp, false> : public true_type {}; // floating point
template <class _Tp, bool = is_arithmetic<_Tp>::value>
struct __libcpp_is_signed : public __libcpp_is_signed_impl<_Tp> {};
template <class _Tp> struct __libcpp_is_signed<_Tp, false> : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_signed : public __libcpp_is_signed<_Tp> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_signed_v = is_signed<_Tp>::value;
#endif
#endif // __has_keyword(__is_signed)
// is_unsigned
// Before Clang 13, __is_unsigned returned true for enums with signed underlying type.
// No currently-released version of AppleClang contains the fixed intrinsic.
#if __has_keyword(__is_unsigned) && \
!(defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER < 1300) && \
!defined(_LIBCPP_APPLE_CLANG_VER)
template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_unsigned : _BoolConstant<__is_unsigned(_Tp)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_unsigned_v = __is_unsigned(_Tp);
#endif
#else // __has_keyword(__is_unsigned)
template <class _Tp, bool = is_integral<_Tp>::value>
struct __libcpp_is_unsigned_impl : public _LIBCPP_BOOL_CONSTANT(_Tp(0) < _Tp(-1)) {};
template <class _Tp>
struct __libcpp_is_unsigned_impl<_Tp, false> : public false_type {}; // floating point
template <class _Tp, bool = is_arithmetic<_Tp>::value>
struct __libcpp_is_unsigned : public __libcpp_is_unsigned_impl<_Tp> {};
template <class _Tp> struct __libcpp_is_unsigned<_Tp, false> : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_unsigned : public __libcpp_is_unsigned<_Tp> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value;
#endif
#endif // __has_keyword(__is_unsigned)
// rank
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS rank
: public integral_constant<size_t, 0> {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS rank<_Tp[]>
: public integral_constant<size_t, rank<_Tp>::value + 1> {};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS rank<_Tp[_Np]>
: public integral_constant<size_t, rank<_Tp>::value + 1> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr size_t rank_v = rank<_Tp>::value;
#endif
// extent
#if __has_keyword(__array_extent)
template<class _Tp, size_t _Dim = 0>
struct _LIBCPP_TEMPLATE_VIS extent
: integral_constant<size_t, __array_extent(_Tp, _Dim)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp, unsigned _Ip = 0>
inline constexpr size_t extent_v = __array_extent(_Tp, _Ip);
#endif
#else // __has_keyword(__array_extent)
template <class _Tp, unsigned _Ip = 0> struct _LIBCPP_TEMPLATE_VIS extent
: public integral_constant<size_t, 0> {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], 0>
: public integral_constant<size_t, 0> {};
template <class _Tp, unsigned _Ip> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], _Ip>
: public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[_Np], 0>
: public integral_constant<size_t, _Np> {};
template <class _Tp, size_t _Np, unsigned _Ip> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[_Np], _Ip>
: public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp, unsigned _Ip = 0>
inline constexpr size_t extent_v = extent<_Tp, _Ip>::value;
#endif
#endif // __has_keyword(__array_extent)
// remove_extent
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_extent
{typedef _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[]>
{typedef _Tp type;};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[_Np]>
{typedef _Tp type;};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using remove_extent_t = typename remove_extent<_Tp>::type;
#endif
// remove_all_extents
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_all_extents
{typedef _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[]>
{typedef typename remove_all_extents<_Tp>::type type;};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[_Np]>
{typedef typename remove_all_extents<_Tp>::type type;};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
#endif
#if _LIBCPP_STD_VER > 17
// is_bounded_array
template <class> struct _LIBCPP_TEMPLATE_VIS is_bounded_array : false_type {};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS is_bounded_array<_Tp[_Np]> : true_type {};
template <class _Tp>
inline constexpr
bool is_bounded_array_v = is_bounded_array<_Tp>::value;
// is_unbounded_array
template <class> struct _LIBCPP_TEMPLATE_VIS is_unbounded_array : false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_unbounded_array<_Tp[]> : true_type {};
template <class _Tp>
inline constexpr
bool is_unbounded_array_v = is_unbounded_array<_Tp>::value;
#endif
// decay
template <class _Up, bool>
struct __decay {
typedef _LIBCPP_NODEBUG typename remove_cv<_Up>::type type;
};
template <class _Up>
struct __decay<_Up, true> {
public:
typedef _LIBCPP_NODEBUG typename conditional
<
is_array<_Up>::value,
typename remove_extent<_Up>::type*,
typename conditional
<
is_function<_Up>::value,
typename add_pointer<_Up>::type,
typename remove_cv<_Up>::type
>::type
>::type type;
};
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS decay
{
private:
typedef _LIBCPP_NODEBUG typename remove_reference<_Tp>::type _Up;
public:
typedef _LIBCPP_NODEBUG typename __decay<_Up, __is_referenceable<_Up>::value>::type type;
};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using decay_t = typename decay<_Tp>::type;
#endif
// is_abstract
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_abstract
: public integral_constant<bool, __is_abstract(_Tp)> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_abstract_v = is_abstract<_Tp>::value;
#endif
// is_final
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS
__libcpp_is_final : public integral_constant<bool, __is_final(_Tp)> {};
#if _LIBCPP_STD_VER > 11
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS
is_final : public integral_constant<bool, __is_final(_Tp)> {};
#endif
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_final_v = is_final<_Tp>::value;
#endif
// is_aggregate
#if _LIBCPP_STD_VER > 14
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS
is_aggregate : public integral_constant<bool, __is_aggregate(_Tp)> {};
template <class _Tp>
inline constexpr bool is_aggregate_v = is_aggregate<_Tp>::value;
#endif // _LIBCPP_STD_VER > 14
// is_base_of
template <class _Bp, class _Dp>
struct _LIBCPP_TEMPLATE_VIS is_base_of
: public integral_constant<bool, __is_base_of(_Bp, _Dp)> {};
#if _LIBCPP_STD_VER > 14
template <class _Bp, class _Dp>
inline constexpr bool is_base_of_v = is_base_of<_Bp, _Dp>::value;
#endif
// __is_core_convertible
// [conv.general]/3 says "E is convertible to T" whenever "T t=E;" is well-formed.
// We can't test for that, but we can test implicit convertibility by passing it
// to a function. Notice that __is_core_convertible<void,void> is false,
// and __is_core_convertible<immovable-type,immovable-type> is true in C++17 and later.
template <class _Tp, class _Up, class = void>
struct __is_core_convertible : public false_type {};
template <class _Tp, class _Up>
struct __is_core_convertible<_Tp, _Up, decltype(
static_cast<void(*)(_Up)>(0) ( static_cast<_Tp(*)()>(0)() )
)> : public true_type {};
// is_convertible
#if __has_feature(is_convertible_to) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK)
template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS is_convertible
: public integral_constant<bool, __is_convertible_to(_T1, _T2)> {};
#else // __has_feature(is_convertible_to)
namespace __is_convertible_imp
{
template <class _Tp> void __test_convert(_Tp);
template <class _From, class _To, class = void>
struct __is_convertible_test : public false_type {};
template <class _From, class _To>
struct __is_convertible_test<_From, _To,
decltype(__is_convertible_imp::__test_convert<_To>(declval<_From>()))> : public true_type
{};
template <class _Tp, bool _IsArray = is_array<_Tp>::value,
bool _IsFunction = is_function<_Tp>::value,
bool _IsVoid = is_void<_Tp>::value>
struct __is_array_function_or_void {enum {value = 0};};
template <class _Tp> struct __is_array_function_or_void<_Tp, true, false, false> {enum {value = 1};};
template <class _Tp> struct __is_array_function_or_void<_Tp, false, true, false> {enum {value = 2};};
template <class _Tp> struct __is_array_function_or_void<_Tp, false, false, true> {enum {value = 3};};
}
template <class _Tp,
unsigned = __is_convertible_imp::__is_array_function_or_void<typename remove_reference<_Tp>::type>::value>
struct __is_convertible_check
{
static const size_t __v = 0;
};
template <class _Tp>
struct __is_convertible_check<_Tp, 0>
{
static const size_t __v = sizeof(_Tp);
};
template <class _T1, class _T2,
unsigned _T1_is_array_function_or_void = __is_convertible_imp::__is_array_function_or_void<_T1>::value,
unsigned _T2_is_array_function_or_void = __is_convertible_imp::__is_array_function_or_void<_T2>::value>
struct __is_convertible
: public integral_constant<bool,
__is_convertible_imp::__is_convertible_test<_T1, _T2>::value
>
{};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 1> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 1> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 1> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 1> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 2> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 2> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 2> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 2> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 3> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 3> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 3> : public false_type {};
template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 3> : public true_type {};
template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS is_convertible
: public __is_convertible<_T1, _T2>
{
static const size_t __complete_check1 = __is_convertible_check<_T1>::__v;
static const size_t __complete_check2 = __is_convertible_check<_T2>::__v;
};
#endif // __has_feature(is_convertible_to)
#if _LIBCPP_STD_VER > 14
template <class _From, class _To>
inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value;
#endif
// is_nothrow_convertible
#if _LIBCPP_STD_VER > 17
template <typename _Tp>
static void __test_noexcept(_Tp) noexcept;
template<typename _Fm, typename _To>
static bool_constant<noexcept(_VSTD::__test_noexcept<_To>(declval<_Fm>()))>
__is_nothrow_convertible_test();
template <typename _Fm, typename _To>
struct __is_nothrow_convertible_helper: decltype(__is_nothrow_convertible_test<_Fm, _To>())
{ };
template <typename _Fm, typename _To>
struct is_nothrow_convertible : _Or<
_And<is_void<_To>, is_void<_Fm>>,
_Lazy<_And, is_convertible<_Fm, _To>, __is_nothrow_convertible_helper<_Fm, _To>>
>::type { };
template <typename _Fm, typename _To>
inline constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<_Fm, _To>::value;
#endif // _LIBCPP_STD_VER > 17
// is_empty
#if __has_feature(is_empty) || defined(_LIBCPP_COMPILER_GCC)
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_empty
: public integral_constant<bool, __is_empty(_Tp)> {};
#else // __has_feature(is_empty)
template <class _Tp>
struct __is_empty1
: public _Tp
{
double __lx;
};
struct __is_empty2
{
double __lx;
};
template <class _Tp, bool = is_class<_Tp>::value>
struct __libcpp_empty : public integral_constant<bool, sizeof(__is_empty1<_Tp>) == sizeof(__is_empty2)> {};
template <class _Tp> struct __libcpp_empty<_Tp, false> : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_empty : public __libcpp_empty<_Tp> {};
#endif // __has_feature(is_empty)
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_empty_v = is_empty<_Tp>::value;
#endif
// is_polymorphic
#if __has_feature(is_polymorphic) || defined(_LIBCPP_COMPILER_MSVC)
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_polymorphic
: public integral_constant<bool, __is_polymorphic(_Tp)> {};
#else
template<typename _Tp> char &__is_polymorphic_impl(
typename enable_if<sizeof((_Tp*)dynamic_cast<const volatile void*>(declval<_Tp*>())) != 0,
int>::type);
template<typename _Tp> __two &__is_polymorphic_impl(...);
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_polymorphic
: public integral_constant<bool, sizeof(__is_polymorphic_impl<_Tp>(0)) == 1> {};
#endif // __has_feature(is_polymorphic)
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_polymorphic_v = is_polymorphic<_Tp>::value;
#endif
// has_virtual_destructor
#if __has_feature(has_virtual_destructor) || defined(_LIBCPP_COMPILER_GCC)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_virtual_destructor
: public integral_constant<bool, __has_virtual_destructor(_Tp)> {};
#else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_virtual_destructor
: public false_type {};
#endif
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool has_virtual_destructor_v = has_virtual_destructor<_Tp>::value;
#endif
// has_unique_object_representations
#if _LIBCPP_STD_VER > 14
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_unique_object_representations
: public integral_constant<bool,
__has_unique_object_representations(remove_cv_t<remove_all_extents_t<_Tp>>)> {};
template <class _Tp>
inline constexpr bool has_unique_object_representations_v = has_unique_object_representations<_Tp>::value;
#endif
// alignment_of
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS alignment_of
: public integral_constant<size_t, _LIBCPP_ALIGNOF(_Tp)> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value;
#endif
// aligned_storage
template <class _Hp, class _Tp>
struct __type_list
{
typedef _Hp _Head;
typedef _Tp _Tail;
};
struct __nat
{
#ifndef _LIBCPP_CXX03_LANG
__nat() = delete;
__nat(const __nat&) = delete;
__nat& operator=(const __nat&) = delete;
~__nat() = delete;
#endif
};
template <class _Tp>
struct __align_type
{
static const size_t value = _LIBCPP_PREFERRED_ALIGNOF(_Tp);
typedef _Tp type;
};
struct __struct_double {long double __lx;};
struct __struct_double4 {double __lx[4];};
typedef
__type_list<__align_type<unsigned char>,
__type_list<__align_type<unsigned short>,
__type_list<__align_type<unsigned int>,
__type_list<__align_type<unsigned long>,
__type_list<__align_type<unsigned long long>,
__type_list<__align_type<double>,
__type_list<__align_type<long double>,
__type_list<__align_type<__struct_double>,
__type_list<__align_type<__struct_double4>,
__type_list<__align_type<int*>,
__nat
> > > > > > > > > > __all_types;
template <size_t _Align>
struct _ALIGNAS(_Align) __fallback_overaligned {};
template <class _TL, size_t _Align> struct __find_pod;
template <class _Hp, size_t _Align>
struct __find_pod<__type_list<_Hp, __nat>, _Align>
{
typedef typename conditional<
_Align == _Hp::value,
typename _Hp::type,
__fallback_overaligned<_Align>
>::type type;
};
template <class _Hp, class _Tp, size_t _Align>
struct __find_pod<__type_list<_Hp, _Tp>, _Align>
{
typedef typename conditional<
_Align == _Hp::value,
typename _Hp::type,
typename __find_pod<_Tp, _Align>::type
>::type type;
};
template <class _TL, size_t _Len> struct __find_max_align;
template <class _Hp, size_t _Len>
struct __find_max_align<__type_list<_Hp, __nat>, _Len> : public integral_constant<size_t, _Hp::value> {};
template <size_t _Len, size_t _A1, size_t _A2>
struct __select_align
{
private:
static const size_t __min = _A2 < _A1 ? _A2 : _A1;
static const size_t __max = _A1 < _A2 ? _A2 : _A1;
public:
static const size_t value = _Len < __max ? __min : __max;
};
template <class _Hp, class _Tp, size_t _Len>
struct __find_max_align<__type_list<_Hp, _Tp>, _Len>
: public integral_constant<size_t, __select_align<_Len, _Hp::value, __find_max_align<_Tp, _Len>::value>::value> {};
template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
struct _LIBCPP_TEMPLATE_VIS aligned_storage
{
typedef typename __find_pod<__all_types, _Align>::type _Aligner;
union type
{
_Aligner __align;
unsigned char __data[(_Len + _Align - 1)/_Align * _Align];
};
};
#if _LIBCPP_STD_VER > 11
template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
#endif
#define _CREATE_ALIGNED_STORAGE_SPECIALIZATION(n) \
template <size_t _Len>\
struct _LIBCPP_TEMPLATE_VIS aligned_storage<_Len, n>\
{\
struct _ALIGNAS(n) type\
{\
unsigned char __lx[(_Len + n - 1)/n * n];\
};\
}
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x1);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x2);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x4);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x8);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x10);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x20);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x40);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x80);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x100);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x200);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x400);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x800);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x1000);
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x2000);
// PE/COFF does not support alignment beyond 8192 (=0x2000)
#if !defined(_LIBCPP_OBJECT_FORMAT_COFF)
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x4000);
#endif // !defined(_LIBCPP_OBJECT_FORMAT_COFF)
#undef _CREATE_ALIGNED_STORAGE_SPECIALIZATION
// aligned_union
template <size_t _I0, size_t ..._In>
struct __static_max;
template <size_t _I0>
struct __static_max<_I0>
{
static const size_t value = _I0;
};
template <size_t _I0, size_t _I1, size_t ..._In>
struct __static_max<_I0, _I1, _In...>
{
static const size_t value = _I0 >= _I1 ? __static_max<_I0, _In...>::value :
__static_max<_I1, _In...>::value;
};
template <size_t _Len, class _Type0, class ..._Types>
struct aligned_union
{
static const size_t alignment_value = __static_max<_LIBCPP_PREFERRED_ALIGNOF(_Type0),
_LIBCPP_PREFERRED_ALIGNOF(_Types)...>::value;
static const size_t __len = __static_max<_Len, sizeof(_Type0),
sizeof(_Types)...>::value;
typedef typename aligned_storage<__len, alignment_value>::type type;
};
#if _LIBCPP_STD_VER > 11
template <size_t _Len, class ..._Types> using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
#endif
template <class _Tp>
struct __numeric_type
{
static void __test(...);
static float __test(float);
static double __test(char);
static double __test(int);
static double __test(unsigned);
static double __test(long);
static double __test(unsigned long);
static double __test(long long);
static double __test(unsigned long long);
static double __test(double);
static long double __test(long double);
typedef decltype(__test(declval<_Tp>())) type;
static const bool value = _IsNotSame<type, void>::value;
};
template <>
struct __numeric_type<void>
{
static const bool value = true;
};
// __promote
template <class _A1, class _A2 = void, class _A3 = void,
bool = __numeric_type<_A1>::value &&
__numeric_type<_A2>::value &&
__numeric_type<_A3>::value>
class __promote_imp
{
public:
static const bool value = false;
};
template <class _A1, class _A2, class _A3>
class __promote_imp<_A1, _A2, _A3, true>
{
private:
typedef typename __promote_imp<_A1>::type __type1;
typedef typename __promote_imp<_A2>::type __type2;
typedef typename __promote_imp<_A3>::type __type3;
public:
typedef decltype(__type1() + __type2() + __type3()) type;
static const bool value = true;
};
template <class _A1, class _A2>
class __promote_imp<_A1, _A2, void, true>
{
private:
typedef typename __promote_imp<_A1>::type __type1;
typedef typename __promote_imp<_A2>::type __type2;
public:
typedef decltype(__type1() + __type2()) type;
static const bool value = true;
};
template <class _A1>
class __promote_imp<_A1, void, void, true>
{
public:
typedef typename __numeric_type<_A1>::type type;
static const bool value = true;
};
template <class _A1, class _A2 = void, class _A3 = void>
class __promote : public __promote_imp<_A1, _A2, _A3> {};
// make_signed / make_unsigned
typedef
__type_list<signed char,
__type_list<signed short,
__type_list<signed int,
__type_list<signed long,
__type_list<signed long long,
#ifndef _LIBCPP_HAS_NO_INT128
__type_list<__int128_t,
#endif
__nat
#ifndef _LIBCPP_HAS_NO_INT128
>
#endif
> > > > > __signed_types;
typedef
__type_list<unsigned char,
__type_list<unsigned short,
__type_list<unsigned int,
__type_list<unsigned long,
__type_list<unsigned long long,
#ifndef _LIBCPP_HAS_NO_INT128
__type_list<__uint128_t,
#endif
__nat
#ifndef _LIBCPP_HAS_NO_INT128
>
#endif
> > > > > __unsigned_types;
template <class _TypeList, size_t _Size, bool = _Size <= sizeof(typename _TypeList::_Head)> struct __find_first;
template <class _Hp, class _Tp, size_t _Size>
struct __find_first<__type_list<_Hp, _Tp>, _Size, true>
{
typedef _LIBCPP_NODEBUG _Hp type;
};
template <class _Hp, class _Tp, size_t _Size>
struct __find_first<__type_list<_Hp, _Tp>, _Size, false>
{
typedef _LIBCPP_NODEBUG typename __find_first<_Tp, _Size>::type type;
};
template <class _Tp, class _Up, bool = is_const<typename remove_reference<_Tp>::type>::value,
bool = is_volatile<typename remove_reference<_Tp>::type>::value>
struct __apply_cv
{
typedef _LIBCPP_NODEBUG _Up type;
};
template <class _Tp, class _Up>
struct __apply_cv<_Tp, _Up, true, false>
{
typedef _LIBCPP_NODEBUG const _Up type;
};
template <class _Tp, class _Up>
struct __apply_cv<_Tp, _Up, false, true>
{
typedef volatile _Up type;
};
template <class _Tp, class _Up>
struct __apply_cv<_Tp, _Up, true, true>
{
typedef const volatile _Up type;
};
template <class _Tp, class _Up>
struct __apply_cv<_Tp&, _Up, false, false>
{
typedef _Up& type;
};
template <class _Tp, class _Up>
struct __apply_cv<_Tp&, _Up, true, false>
{
typedef const _Up& type;
};
template <class _Tp, class _Up>
struct __apply_cv<_Tp&, _Up, false, true>
{
typedef volatile _Up& type;
};
template <class _Tp, class _Up>
struct __apply_cv<_Tp&, _Up, true, true>
{
typedef const volatile _Up& type;
};
template <class _Tp, bool = is_integral<_Tp>::value || is_enum<_Tp>::value>
struct __make_signed {};
template <class _Tp>
struct __make_signed<_Tp, true>
{
typedef typename __find_first<__signed_types, sizeof(_Tp)>::type type;
};
template <> struct __make_signed<bool, true> {};
template <> struct __make_signed< signed short, true> {typedef short type;};
template <> struct __make_signed<unsigned short, true> {typedef short type;};
template <> struct __make_signed< signed int, true> {typedef int type;};
template <> struct __make_signed<unsigned int, true> {typedef int type;};
template <> struct __make_signed< signed long, true> {typedef long type;};
template <> struct __make_signed<unsigned long, true> {typedef long type;};
template <> struct __make_signed< signed long long, true> {typedef long long type;};
template <> struct __make_signed<unsigned long long, true> {typedef long long type;};
#ifndef _LIBCPP_HAS_NO_INT128
template <> struct __make_signed<__int128_t, true> {typedef __int128_t type;};
template <> struct __make_signed<__uint128_t, true> {typedef __int128_t type;};
#endif
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS make_signed
{
typedef typename __apply_cv<_Tp, typename __make_signed<typename remove_cv<_Tp>::type>::type>::type type;
};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using make_signed_t = typename make_signed<_Tp>::type;
#endif
template <class _Tp, bool = is_integral<_Tp>::value || is_enum<_Tp>::value>
struct __make_unsigned {};
template <class _Tp>
struct __make_unsigned<_Tp, true>
{
typedef typename __find_first<__unsigned_types, sizeof(_Tp)>::type type;
};
template <> struct __make_unsigned<bool, true> {};
template <> struct __make_unsigned< signed short, true> {typedef unsigned short type;};
template <> struct __make_unsigned<unsigned short, true> {typedef unsigned short type;};
template <> struct __make_unsigned< signed int, true> {typedef unsigned int type;};
template <> struct __make_unsigned<unsigned int, true> {typedef unsigned int type;};
template <> struct __make_unsigned< signed long, true> {typedef unsigned long type;};
template <> struct __make_unsigned<unsigned long, true> {typedef unsigned long type;};
template <> struct __make_unsigned< signed long long, true> {typedef unsigned long long type;};
template <> struct __make_unsigned<unsigned long long, true> {typedef unsigned long long type;};
#ifndef _LIBCPP_HAS_NO_INT128
template <> struct __make_unsigned<__int128_t, true> {typedef __uint128_t type;};
template <> struct __make_unsigned<__uint128_t, true> {typedef __uint128_t type;};
#endif
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS make_unsigned
{
typedef typename __apply_cv<_Tp, typename __make_unsigned<typename remove_cv<_Tp>::type>::type>::type type;
};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using make_unsigned_t = typename make_unsigned<_Tp>::type;
#endif
#ifndef _LIBCPP_CXX03_LANG
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr
typename make_unsigned<_Tp>::type __to_unsigned_like(_Tp __x) noexcept {
return static_cast<typename make_unsigned<_Tp>::type>(__x);
}
#endif
#if _LIBCPP_STD_VER > 14
template <class...> using void_t = void;
#endif
#if _LIBCPP_STD_VER > 17
// Let COND_RES(X, Y) be:
template <class _Tp, class _Up>
using __cond_type = decltype(false ? declval<_Tp>() : declval<_Up>());
template <class _Tp, class _Up, class = void>
struct __common_type3 {};
// sub-bullet 4 - "if COND_RES(CREF(D1), CREF(D2)) denotes a type..."
template <class _Tp, class _Up>
struct __common_type3<_Tp, _Up, void_t<__cond_type<const _Tp&, const _Up&>>>
{
using type = remove_cvref_t<__cond_type<const _Tp&, const _Up&>>;
};
template <class _Tp, class _Up, class = void>
struct __common_type2_imp : __common_type3<_Tp, _Up> {};
#else
template <class _Tp, class _Up, class = void>
struct __common_type2_imp {};
#endif
// sub-bullet 3 - "if decay_t<decltype(false ? declval<D1>() : declval<D2>())> ..."
template <class _Tp, class _Up>
struct __common_type2_imp<_Tp, _Up,
typename __void_t<decltype(
true ? declval<_Tp>() : declval<_Up>()
)>::type>
{
typedef _LIBCPP_NODEBUG typename decay<decltype(
true ? declval<_Tp>() : declval<_Up>()
)>::type type;
};
template <class, class = void>
struct __common_type_impl {};
// Clang provides variadic templates in C++03 as an extension.
#if !defined(_LIBCPP_CXX03_LANG) || defined(__clang__)
# define _LIBCPP_OPTIONAL_PACK(...) , __VA_ARGS__
template <class... _Tp>
struct __common_types;
template <class... _Tp>
struct _LIBCPP_TEMPLATE_VIS common_type;
#else
# define _LIBCPP_OPTIONAL_PACK(...)
struct __no_arg;
template <class _Tp, class _Up, class = __no_arg>
struct __common_types;
template <class _Tp = __no_arg, class _Up = __no_arg, class _Vp = __no_arg,
class _Unused = __no_arg>
struct common_type {
static_assert(sizeof(_Unused) == 0,
"common_type accepts at most 3 arguments in C++03");
};
#endif // _LIBCPP_CXX03_LANG
template <class _Tp, class _Up>
struct __common_type_impl<
__common_types<_Tp, _Up>,
typename __void_t<typename common_type<_Tp, _Up>::type>::type>
{
typedef typename common_type<_Tp, _Up>::type type;
};
template <class _Tp, class _Up, class _Vp _LIBCPP_OPTIONAL_PACK(class... _Rest)>
struct __common_type_impl<
__common_types<_Tp, _Up, _Vp _LIBCPP_OPTIONAL_PACK(_Rest...)>,
typename __void_t<typename common_type<_Tp, _Up>::type>::type>
: __common_type_impl<__common_types<typename common_type<_Tp, _Up>::type,
_Vp _LIBCPP_OPTIONAL_PACK(_Rest...)> > {
};
// bullet 1 - sizeof...(Tp) == 0
template <>
struct _LIBCPP_TEMPLATE_VIS common_type<> {};
// bullet 2 - sizeof...(Tp) == 1
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS common_type<_Tp>
: public common_type<_Tp, _Tp> {};
// bullet 3 - sizeof...(Tp) == 2
// sub-bullet 1 - "If is_same_v<T1, D1> is false or ..."
template <class _Tp, class _Up>
struct _LIBCPP_TEMPLATE_VIS common_type<_Tp, _Up>
: conditional<
_IsSame<_Tp, typename decay<_Tp>::type>::value && _IsSame<_Up, typename decay<_Up>::type>::value,
__common_type2_imp<_Tp, _Up>,
common_type<typename decay<_Tp>::type, typename decay<_Up>::type>
>::type
{};
// bullet 4 - sizeof...(Tp) > 2
template <class _Tp, class _Up, class _Vp _LIBCPP_OPTIONAL_PACK(class... _Rest)>
struct _LIBCPP_TEMPLATE_VIS
common_type<_Tp, _Up, _Vp _LIBCPP_OPTIONAL_PACK(_Rest...)>
: __common_type_impl<
__common_types<_Tp, _Up, _Vp _LIBCPP_OPTIONAL_PACK(_Rest...)> > {};
#undef _LIBCPP_OPTIONAL_PACK
#if _LIBCPP_STD_VER > 11
template <class ..._Tp> using common_type_t = typename common_type<_Tp...>::type;
#endif
#if _LIBCPP_STD_VER > 11
// Let COPYCV(FROM, TO) be an alias for type TO with the addition of FROM's
// top-level cv-qualifiers.
template <class _From, class _To>
struct __copy_cv
{
using type = _To;
};
template <class _From, class _To>
struct __copy_cv<const _From, _To>
{
using type = add_const_t<_To>;
};
template <class _From, class _To>
struct __copy_cv<volatile _From, _To>
{
using type = add_volatile_t<_To>;
};
template <class _From, class _To>
struct __copy_cv<const volatile _From, _To>
{
using type = add_cv_t<_To>;
};
template <class _From, class _To>
using __copy_cv_t = typename __copy_cv<_From, _To>::type;
template <class _From, class _To>
struct __copy_cvref
{
using type = __copy_cv_t<_From, _To>;
};
template <class _From, class _To>
struct __copy_cvref<_From&, _To>
{
using type = add_lvalue_reference_t<__copy_cv_t<_From, _To>>;
};
template <class _From, class _To>
struct __copy_cvref<_From&&, _To>
{
using type = add_rvalue_reference_t<__copy_cv_t<_From, _To>>;
};
template <class _From, class _To>
using __copy_cvref_t = typename __copy_cvref<_From, _To>::type;
#endif // _LIBCPP_STD_VER > 11
// common_reference
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// Let COND_RES(X, Y) be:
template <class _Xp, class _Yp>
using __cond_res =
decltype(false ? declval<_Xp(&)()>()() : declval<_Yp(&)()>()());
// Let `XREF(A)` denote a unary alias template `T` such that `T<U>` denotes the same type as `U`
// with the addition of `A`'s cv and reference qualifiers, for a non-reference cv-unqualified type
// `U`.
// [Note: `XREF(A)` is `__xref<A>::template __apply`]
template <class _Tp>
struct __xref {
template<class _Up>
using __apply = __copy_cvref_t<_Tp, _Up>;
};
// Given types A and B, let X be remove_reference_t<A>, let Y be remove_reference_t<B>,
// and let COMMON-REF(A, B) be:
template<class _Ap, class _Bp, class _Xp = remove_reference_t<_Ap>, class _Yp = remove_reference_t<_Bp>>
struct __common_ref;
template<class _Xp, class _Yp>
using __common_ref_t = typename __common_ref<_Xp, _Yp>::__type;
template<class _Xp, class _Yp>
using __cv_cond_res = __cond_res<__copy_cv_t<_Xp, _Yp>&, __copy_cv_t<_Yp, _Xp>&>;
// If A and B are both lvalue reference types, COMMON-REF(A, B) is
// COND-RES(COPYCV(X, Y)&, COPYCV(Y, X)&) if that type exists and is a reference type.
template<class _Ap, class _Bp, class _Xp, class _Yp>
requires requires { typename __cv_cond_res<_Xp, _Yp>; } && is_reference_v<__cv_cond_res<_Xp, _Yp>>
struct __common_ref<_Ap&, _Bp&, _Xp, _Yp>
{
using __type = __cv_cond_res<_Xp, _Yp>;
};
// Otherwise, let C be remove_reference_t<COMMON-REF(X&, Y&)>&&. ...
template <class _Xp, class _Yp>
using __common_ref_C = remove_reference_t<__common_ref_t<_Xp&, _Yp&>>&&;
// .... If A and B are both rvalue reference types, C is well-formed, and
// is_convertible_v<A, C> && is_convertible_v<B, C> is true, then COMMON-REF(A, B) is C.
template<class _Ap, class _Bp, class _Xp, class _Yp>
requires
requires { typename __common_ref_C<_Xp, _Yp>; } &&
is_convertible_v<_Ap&&, __common_ref_C<_Xp, _Yp>> &&
is_convertible_v<_Bp&&, __common_ref_C<_Xp, _Yp>>
struct __common_ref<_Ap&&, _Bp&&, _Xp, _Yp>
{
using __type = __common_ref_C<_Xp, _Yp>;
};
// Otherwise, let D be COMMON-REF(const X&, Y&). ...
template <class _Tp, class _Up>
using __common_ref_D = __common_ref_t<const _Tp&, _Up&>;
// ... If A is an rvalue reference and B is an lvalue reference and D is well-formed and
// is_convertible_v<A, D> is true, then COMMON-REF(A, B) is D.
template<class _Ap, class _Bp, class _Xp, class _Yp>
requires requires { typename __common_ref_D<_Xp, _Yp>; } &&
is_convertible_v<_Ap&&, __common_ref_D<_Xp, _Yp>>
struct __common_ref<_Ap&&, _Bp&, _Xp, _Yp>
{
using __type = __common_ref_D<_Xp, _Yp>;
};
// Otherwise, if A is an lvalue reference and B is an rvalue reference, then
// COMMON-REF(A, B) is COMMON-REF(B, A).
template<class _Ap, class _Bp, class _Xp, class _Yp>
struct __common_ref<_Ap&, _Bp&&, _Xp, _Yp> : __common_ref<_Bp&&, _Ap&> {};
// Otherwise, COMMON-REF(A, B) is ill-formed.
template<class _Ap, class _Bp, class _Xp, class _Yp>
struct __common_ref {};
// Note C: For the common_reference trait applied to a parameter pack [...]
template <class...>
struct common_reference;
template <class... _Types>
using common_reference_t = typename common_reference<_Types...>::type;
// bullet 1 - sizeof...(T) == 0
template<>
struct common_reference<> {};
// bullet 2 - sizeof...(T) == 1
template <class _Tp>
struct common_reference<_Tp>
{
using type = _Tp;
};
// bullet 3 - sizeof...(T) == 2
template <class _Tp, class _Up> struct __common_reference_sub_bullet3;
template <class _Tp, class _Up> struct __common_reference_sub_bullet2 : __common_reference_sub_bullet3<_Tp, _Up> {};
template <class _Tp, class _Up> struct __common_reference_sub_bullet1 : __common_reference_sub_bullet2<_Tp, _Up> {};
// sub-bullet 1 - If T1 and T2 are reference types and COMMON-REF(T1, T2) is well-formed, then
// the member typedef `type` denotes that type.
template <class _Tp, class _Up> struct common_reference<_Tp, _Up> : __common_reference_sub_bullet1<_Tp, _Up> {};
template <class _Tp, class _Up>
requires is_reference_v<_Tp> && is_reference_v<_Up> && requires { typename __common_ref_t<_Tp, _Up>; }
struct __common_reference_sub_bullet1<_Tp, _Up>
{
using type = __common_ref_t<_Tp, _Up>;
};
// sub-bullet 2 - Otherwise, if basic_common_reference<remove_cvref_t<T1>, remove_cvref_t<T2>, XREF(T1), XREF(T2)>::type
// is well-formed, then the member typedef `type` denotes that type.
template <class, class, template <class> class, template <class> class> struct basic_common_reference {};
template <class _Tp, class _Up>
using __basic_common_reference_t = typename basic_common_reference<
remove_cvref_t<_Tp>, remove_cvref_t<_Up>,
__xref<_Tp>::template __apply, __xref<_Up>::template __apply>::type;
template <class _Tp, class _Up>
requires requires { typename __basic_common_reference_t<_Tp, _Up>; }
struct __common_reference_sub_bullet2<_Tp, _Up>
{
using type = __basic_common_reference_t<_Tp, _Up>;
};
// sub-bullet 3 - Otherwise, if COND-RES(T1, T2) is well-formed,
// then the member typedef `type` denotes that type.
template <class _Tp, class _Up>
requires requires { typename __cond_res<_Tp, _Up>; }
struct __common_reference_sub_bullet3<_Tp, _Up>
{
using type = __cond_res<_Tp, _Up>;
};
// sub-bullet 4 & 5 - Otherwise, if common_type_t<T1, T2> is well-formed,
// then the member typedef `type` denotes that type.
// - Otherwise, there shall be no member `type`.
template <class _Tp, class _Up> struct __common_reference_sub_bullet3 : common_type<_Tp, _Up> {};
// bullet 4 - If there is such a type `C`, the member typedef type shall denote the same type, if
// any, as `common_reference_t<C, Rest...>`.
template <class _Tp, class _Up, class _Vp, class... _Rest>
requires requires { typename common_reference_t<_Tp, _Up>; }
struct common_reference<_Tp, _Up, _Vp, _Rest...>
: common_reference<common_reference_t<_Tp, _Up>, _Vp, _Rest...>
{};
// bullet 5 - Otherwise, there shall be no member `type`.
template <class...> struct common_reference {};
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
// is_assignable
template<typename, typename _Tp> struct __select_2nd { typedef _LIBCPP_NODEBUG _Tp type; };
#if __has_keyword(__is_assignable)
template<class _Tp, class _Up>
struct _LIBCPP_TEMPLATE_VIS is_assignable : _BoolConstant<__is_assignable(_Tp, _Up)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp, class _Arg>
inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Arg);
#endif
#else // __has_keyword(__is_assignable)
template <class _Tp, class _Arg>
typename __select_2nd<decltype((declval<_Tp>() = declval<_Arg>())), true_type>::type
__is_assignable_test(int);
template <class, class>
false_type __is_assignable_test(...);
template <class _Tp, class _Arg, bool = is_void<_Tp>::value || is_void<_Arg>::value>
struct __is_assignable_imp
: public decltype((_VSTD::__is_assignable_test<_Tp, _Arg>(0))) {};
template <class _Tp, class _Arg>
struct __is_assignable_imp<_Tp, _Arg, true>
: public false_type
{
};
template <class _Tp, class _Arg>
struct is_assignable
: public __is_assignable_imp<_Tp, _Arg> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp, class _Arg>
inline constexpr bool is_assignable_v = is_assignable<_Tp, _Arg>::value;
#endif
#endif // __has_keyword(__is_assignable)
// is_copy_assignable
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_copy_assignable
: public is_assignable<typename add_lvalue_reference<_Tp>::type,
typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value;
#endif
// is_move_assignable
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_move_assignable
: public is_assignable<typename add_lvalue_reference<_Tp>::type,
typename add_rvalue_reference<_Tp>::type> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value;
#endif
// is_destructible
#if __has_keyword(__is_destructible)
template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_destructible : _BoolConstant<__is_destructible(_Tp)> { };
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_destructible_v = __is_destructible(_Tp);
#endif
#else // __has_keyword(__is_destructible)
// if it's a reference, return true
// if it's a function, return false
// if it's void, return false
// if it's an array of unknown bound, return false
// Otherwise, return "declval<_Up&>().~_Up()" is well-formed
// where _Up is remove_all_extents<_Tp>::type
template <class>
struct __is_destructible_apply { typedef int type; };
template <typename _Tp>
struct __is_destructor_wellformed {
template <typename _Tp1>
static char __test (
typename __is_destructible_apply<decltype(declval<_Tp1&>().~_Tp1())>::type
);
template <typename _Tp1>
static __two __test (...);
static const bool value = sizeof(__test<_Tp>(12)) == sizeof(char);
};
template <class _Tp, bool>
struct __destructible_imp;
template <class _Tp>
struct __destructible_imp<_Tp, false>
: public integral_constant<bool,
__is_destructor_wellformed<typename remove_all_extents<_Tp>::type>::value> {};
template <class _Tp>
struct __destructible_imp<_Tp, true>
: public true_type {};
template <class _Tp, bool>
struct __destructible_false;
template <class _Tp>
struct __destructible_false<_Tp, false> : public __destructible_imp<_Tp, is_reference<_Tp>::value> {};
template <class _Tp>
struct __destructible_false<_Tp, true> : public false_type {};
template <class _Tp>
struct is_destructible
: public __destructible_false<_Tp, is_function<_Tp>::value> {};
template <class _Tp>
struct is_destructible<_Tp[]>
: public false_type {};
template <>
struct is_destructible<void>
: public false_type {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_destructible_v = is_destructible<_Tp>::value;
#endif
#endif // __has_keyword(__is_destructible)
template <class _MP, bool _IsMemberFunctionPtr, bool _IsMemberObjectPtr>
struct __member_pointer_traits_imp
{
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...), true, false>
{
typedef _Class _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...), true, false>
{
typedef _Class _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param..., ...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const, true, false>
{
typedef _Class const _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const, true, false>
{
typedef _Class const _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param..., ...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile, true, false>
{
typedef _Class volatile _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) volatile, true, false>
{
typedef _Class volatile _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param..., ...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile, true, false>
{
typedef _Class const volatile _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const volatile, true, false>
{
typedef _Class const volatile _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param..., ...);
};
#if __has_feature(cxx_reference_qualified_functions) || defined(_LIBCPP_COMPILER_GCC)
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) &, true, false>
{
typedef _Class& _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) &, true, false>
{
typedef _Class& _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param..., ...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const&, true, false>
{
typedef _Class const& _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const&, true, false>
{
typedef _Class const& _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param..., ...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile&, true, false>
{
typedef _Class volatile& _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) volatile&, true, false>
{
typedef _Class volatile& _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param..., ...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile&, true, false>
{
typedef _Class const volatile& _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const volatile&, true, false>
{
typedef _Class const volatile& _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param..., ...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) &&, true, false>
{
typedef _Class&& _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) &&, true, false>
{
typedef _Class&& _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param..., ...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const&&, true, false>
{
typedef _Class const&& _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const&&, true, false>
{
typedef _Class const&& _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param..., ...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile&&, true, false>
{
typedef _Class volatile&& _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) volatile&&, true, false>
{
typedef _Class volatile&& _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param..., ...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile&&, true, false>
{
typedef _Class const volatile&& _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param...);
};
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const volatile&&, true, false>
{
typedef _Class const volatile&& _ClassType;
typedef _Rp _ReturnType;
typedef _Rp (_FnType) (_Param..., ...);
};
#endif // __has_feature(cxx_reference_qualified_functions) || defined(_LIBCPP_COMPILER_GCC)
template <class _Rp, class _Class>
struct __member_pointer_traits_imp<_Rp _Class::*, false, true>
{
typedef _Class _ClassType;
typedef _Rp _ReturnType;
};
template <class _MP>
struct __member_pointer_traits
: public __member_pointer_traits_imp<typename remove_cv<_MP>::type,
is_member_function_pointer<_MP>::value,
is_member_object_pointer<_MP>::value>
{
// typedef ... _ClassType;
// typedef ... _ReturnType;
// typedef ... _FnType;
};
template <class _DecayedFp>
struct __member_pointer_class_type {};
template <class _Ret, class _ClassType>
struct __member_pointer_class_type<_Ret _ClassType::*> {
typedef _ClassType type;
};
// template <class T, class... Args> struct is_constructible;
template <class _Tp, class ..._Args>
struct _LIBCPP_TEMPLATE_VIS is_constructible
: public integral_constant<bool, __is_constructible(_Tp, _Args...)>
{ };
#if _LIBCPP_STD_VER > 14
template <class _Tp, class ..._Args>
inline constexpr bool is_constructible_v = is_constructible<_Tp, _Args...>::value;
#endif
// is_default_constructible
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_default_constructible
: public is_constructible<_Tp>
{};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_default_constructible_v = is_default_constructible<_Tp>::value;
#endif
#ifndef _LIBCPP_CXX03_LANG
// First of all, we can't implement this check in C++03 mode because the {}
// default initialization syntax isn't valid.
// Second, we implement the trait in a funny manner with two defaulted template
// arguments to workaround Clang's PR43454.
template <class _Tp>
void __test_implicit_default_constructible(_Tp);
template <class _Tp, class = void, class = typename is_default_constructible<_Tp>::type>
struct __is_implicitly_default_constructible
: false_type
{ };
template <class _Tp>
struct __is_implicitly_default_constructible<_Tp, decltype(__test_implicit_default_constructible<_Tp const&>({})), true_type>
: true_type
{ };
template <class _Tp>
struct __is_implicitly_default_constructible<_Tp, decltype(__test_implicit_default_constructible<_Tp const&>({})), false_type>
: false_type
{ };
#endif // !C++03
// is_copy_constructible
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_copy_constructible
: public is_constructible<_Tp,
typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_copy_constructible_v = is_copy_constructible<_Tp>::value;
#endif
// is_move_constructible
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_move_constructible
: public is_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
{};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_move_constructible_v = is_move_constructible<_Tp>::value;
#endif
// is_trivially_constructible
template <class _Tp, class... _Args>
struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible
: integral_constant<bool, __is_trivially_constructible(_Tp, _Args...)>
{
};
#if _LIBCPP_STD_VER > 14
template <class _Tp, class... _Args>
inline constexpr bool is_trivially_constructible_v = is_trivially_constructible<_Tp, _Args...>::value;
#endif
// is_trivially_default_constructible
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_default_constructible
: public is_trivially_constructible<_Tp>
{};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_trivially_default_constructible_v = is_trivially_default_constructible<_Tp>::value;
#endif
// is_trivially_copy_constructible
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_constructible
: public is_trivially_constructible<_Tp, typename add_lvalue_reference<const _Tp>::type>
{};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible<_Tp>::value;
#endif
// is_trivially_move_constructible
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_move_constructible
: public is_trivially_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
{};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_trivially_move_constructible_v = is_trivially_move_constructible<_Tp>::value;
#endif
// is_trivially_assignable
template <class _Tp, class _Arg>
struct is_trivially_assignable
: integral_constant<bool, __is_trivially_assignable(_Tp, _Arg)>
{ };
#if _LIBCPP_STD_VER > 14
template <class _Tp, class _Arg>
inline constexpr bool is_trivially_assignable_v = is_trivially_assignable<_Tp, _Arg>::value;
#endif
// is_trivially_copy_assignable
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_assignable
: public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable<_Tp>::value;
#endif
// is_trivially_move_assignable
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_move_assignable
: public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
typename add_rvalue_reference<_Tp>::type>
{};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<_Tp>::value;
#endif
// is_trivially_destructible
#if __has_keyword(__is_trivially_destructible)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible
: public integral_constant<bool, __is_trivially_destructible(_Tp)> {};
#elif __has_feature(has_trivial_destructor) || defined(_LIBCPP_COMPILER_GCC)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible
: public integral_constant<bool, is_destructible<_Tp>::value && __has_trivial_destructor(_Tp)> {};
#else
template <class _Tp> struct __libcpp_trivial_destructor
: public integral_constant<bool, is_scalar<_Tp>::value ||
is_reference<_Tp>::value> {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible
: public __libcpp_trivial_destructor<typename remove_all_extents<_Tp>::type> {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible<_Tp[]>
: public false_type {};
#endif
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_trivially_destructible_v = is_trivially_destructible<_Tp>::value;
#endif
// is_nothrow_constructible
#if __has_keyword(__is_nothrow_constructible)
template <class _Tp, class... _Args>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible
: public integral_constant<bool, __is_nothrow_constructible(_Tp, _Args...)> {};
#else
template <bool, bool, class _Tp, class... _Args> struct __libcpp_is_nothrow_constructible;
template <class _Tp, class... _Args>
struct __libcpp_is_nothrow_constructible</*is constructible*/true, /*is reference*/false, _Tp, _Args...>
: public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
{
};
template <class _Tp>
void __implicit_conversion_to(_Tp) noexcept { }
template <class _Tp, class _Arg>
struct __libcpp_is_nothrow_constructible</*is constructible*/true, /*is reference*/true, _Tp, _Arg>
: public integral_constant<bool, noexcept(_VSTD::__implicit_conversion_to<_Tp>(declval<_Arg>()))>
{
};
template <class _Tp, bool _IsReference, class... _Args>
struct __libcpp_is_nothrow_constructible</*is constructible*/false, _IsReference, _Tp, _Args...>
: public false_type
{
};
template <class _Tp, class... _Args>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible
: __libcpp_is_nothrow_constructible<is_constructible<_Tp, _Args...>::value, is_reference<_Tp>::value, _Tp, _Args...>
{
};
template <class _Tp, size_t _Ns>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp[_Ns]>
: __libcpp_is_nothrow_constructible<is_constructible<_Tp>::value, is_reference<_Tp>::value, _Tp>
{
};
#endif // _LIBCPP_HAS_NO_NOEXCEPT
#if _LIBCPP_STD_VER > 14
template <class _Tp, class ..._Args>
inline constexpr bool is_nothrow_constructible_v = is_nothrow_constructible<_Tp, _Args...>::value;
#endif
// is_nothrow_default_constructible
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_default_constructible
: public is_nothrow_constructible<_Tp>
{};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_nothrow_default_constructible_v = is_nothrow_default_constructible<_Tp>::value;
#endif
// is_nothrow_copy_constructible
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_constructible
: public is_nothrow_constructible<_Tp,
typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<_Tp>::value;
#endif
// is_nothrow_move_constructible
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_constructible
: public is_nothrow_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
{};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<_Tp>::value;
#endif
// is_nothrow_assignable
#if __has_keyword(__is_nothrow_assignable)
template <class _Tp, class _Arg>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable
: public integral_constant<bool, __is_nothrow_assignable(_Tp, _Arg)> {};
#else
template <bool, class _Tp, class _Arg> struct __libcpp_is_nothrow_assignable;
template <class _Tp, class _Arg>
struct __libcpp_is_nothrow_assignable<false, _Tp, _Arg>
: public false_type
{
};
template <class _Tp, class _Arg>
struct __libcpp_is_nothrow_assignable<true, _Tp, _Arg>
: public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Arg>()) >
{
};
template <class _Tp, class _Arg>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable
: public __libcpp_is_nothrow_assignable<is_assignable<_Tp, _Arg>::value, _Tp, _Arg>
{
};
#endif // _LIBCPP_HAS_NO_NOEXCEPT
#if _LIBCPP_STD_VER > 14
template <class _Tp, class _Arg>
inline constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<_Tp, _Arg>::value;
#endif
// is_nothrow_copy_assignable
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_assignable
: public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<_Tp>::value;
#endif
// is_nothrow_move_assignable
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_assignable
: public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
typename add_rvalue_reference<_Tp>::type>
{};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<_Tp>::value;
#endif
// is_nothrow_destructible
#if !defined(_LIBCPP_CXX03_LANG)
template <bool, class _Tp> struct __libcpp_is_nothrow_destructible;
template <class _Tp>
struct __libcpp_is_nothrow_destructible<false, _Tp>
: public false_type
{
};
template <class _Tp>
struct __libcpp_is_nothrow_destructible<true, _Tp>
: public integral_constant<bool, noexcept(declval<_Tp>().~_Tp()) >
{
};
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible
: public __libcpp_is_nothrow_destructible<is_destructible<_Tp>::value, _Tp>
{
};
template <class _Tp, size_t _Ns>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp[_Ns]>
: public is_nothrow_destructible<_Tp>
{
};
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp&>
: public true_type
{
};
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp&&>
: public true_type
{
};
#else
template <class _Tp> struct __libcpp_nothrow_destructor
: public integral_constant<bool, is_scalar<_Tp>::value ||
is_reference<_Tp>::value> {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible
: public __libcpp_nothrow_destructor<typename remove_all_extents<_Tp>::type> {};
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp[]>
: public false_type {};
#endif
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<_Tp>::value;
#endif
// is_pod
#if __has_feature(is_pod) || defined(_LIBCPP_COMPILER_GCC)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pod
: public integral_constant<bool, __is_pod(_Tp)> {};
#else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pod
: public integral_constant<bool, is_trivially_default_constructible<_Tp>::value &&
is_trivially_copy_constructible<_Tp>::value &&
is_trivially_copy_assignable<_Tp>::value &&
is_trivially_destructible<_Tp>::value> {};
#endif
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_pod_v = is_pod<_Tp>::value;
#endif
// is_literal_type;
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 is_literal_type
: public integral_constant<bool, __is_literal_type(_Tp)>
{};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
_LIBCPP_DEPRECATED_IN_CXX17 inline constexpr bool is_literal_type_v = is_literal_type<_Tp>::value;
#endif // _LIBCPP_STD_VER > 14
#endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
// is_standard_layout;
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_standard_layout
#if __has_feature(is_standard_layout) || defined(_LIBCPP_COMPILER_GCC)
: public integral_constant<bool, __is_standard_layout(_Tp)>
#else
: integral_constant<bool, is_scalar<typename remove_all_extents<_Tp>::type>::value>
#endif
{};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_standard_layout_v = is_standard_layout<_Tp>::value;
#endif
// is_trivially_copyable;
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copyable
: public integral_constant<bool, __is_trivially_copyable(_Tp)>
{};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_trivially_copyable_v = is_trivially_copyable<_Tp>::value;
#endif
// is_trivial;
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivial
#if __has_feature(is_trivial) || defined(_LIBCPP_COMPILER_GCC)
: public integral_constant<bool, __is_trivial(_Tp)>
#else
: integral_constant<bool, is_trivially_copyable<_Tp>::value &&
is_trivially_default_constructible<_Tp>::value>
#endif
{};
#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_trivial_v = is_trivial<_Tp>::value;
#endif
template <class _Tp> struct __is_reference_wrapper_impl : public false_type {};
template <class _Tp> struct __is_reference_wrapper_impl<reference_wrapper<_Tp> > : public true_type {};
template <class _Tp> struct __is_reference_wrapper
: public __is_reference_wrapper_impl<typename remove_cv<_Tp>::type> {};
#ifndef _LIBCPP_CXX03_LANG
template <class _Fp, class _A0,
class _DecayFp = typename decay<_Fp>::type,
class _DecayA0 = typename decay<_A0>::type,
class _ClassT = typename __member_pointer_class_type<_DecayFp>::type>
using __enable_if_bullet1 = typename enable_if
<
is_member_function_pointer<_DecayFp>::value
&& is_base_of<_ClassT, _DecayA0>::value
>::type;
template <class _Fp, class _A0,
class _DecayFp = typename decay<_Fp>::type,
class _DecayA0 = typename decay<_A0>::type>
using __enable_if_bullet2 = typename enable_if
<
is_member_function_pointer<_DecayFp>::value
&& __is_reference_wrapper<_DecayA0>::value
>::type;
template <class _Fp, class _A0,
class _DecayFp = typename decay<_Fp>::type,
class _DecayA0 = typename decay<_A0>::type,
class _ClassT = typename __member_pointer_class_type<_DecayFp>::type>
using __enable_if_bullet3 = typename enable_if
<
is_member_function_pointer<_DecayFp>::value
&& !is_base_of<_ClassT, _DecayA0>::value
&& !__is_reference_wrapper<_DecayA0>::value
>::type;
template <class _Fp, class _A0,
class _DecayFp = typename decay<_Fp>::type,
class _DecayA0 = typename decay<_A0>::type,
class _ClassT = typename __member_pointer_class_type<_DecayFp>::type>
using __enable_if_bullet4 = typename enable_if
<
is_member_object_pointer<_DecayFp>::value
&& is_base_of<_ClassT, _DecayA0>::value
>::type;
template <class _Fp, class _A0,
class _DecayFp = typename decay<_Fp>::type,
class _DecayA0 = typename decay<_A0>::type>
using __enable_if_bullet5 = typename enable_if
<
is_member_object_pointer<_DecayFp>::value
&& __is_reference_wrapper<_DecayA0>::value
>::type;
template <class _Fp, class _A0,
class _DecayFp = typename decay<_Fp>::type,
class _DecayA0 = typename decay<_A0>::type,
class _ClassT = typename __member_pointer_class_type<_DecayFp>::type>
using __enable_if_bullet6 = typename enable_if
<
is_member_object_pointer<_DecayFp>::value
&& !is_base_of<_ClassT, _DecayA0>::value
&& !__is_reference_wrapper<_DecayA0>::value
>::type;
// __invoke forward declarations
// fall back - none of the bullets
template <class ..._Args>
auto __invoke(__any, _Args&& ...__args) -> __nat;
template <class ..._Args>
auto __invoke_constexpr(__any, _Args&& ...__args) -> __nat;
// bullets 1, 2 and 3
template <class _Fp, class _A0, class ..._Args,
class = __enable_if_bullet1<_Fp, _A0>>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
noexcept(noexcept((static_cast<_A0&&>(__a0).*__f)(static_cast<_Args&&>(__args)...)))
-> decltype( (static_cast<_A0&&>(__a0).*__f)(static_cast<_Args&&>(__args)...))
{ return (static_cast<_A0&&>(__a0).*__f)(static_cast<_Args&&>(__args)...); }
template <class _Fp, class _A0, class ..._Args,
class = __enable_if_bullet1<_Fp, _A0>>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR auto
__invoke_constexpr(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
noexcept(noexcept((static_cast<_A0&&>(__a0).*__f)(static_cast<_Args&&>(__args)...)))
-> decltype( (static_cast<_A0&&>(__a0).*__f)(static_cast<_Args&&>(__args)...))
{ return (static_cast<_A0&&>(__a0).*__f)(static_cast<_Args&&>(__args)...); }
template <class _Fp, class _A0, class ..._Args,
class = __enable_if_bullet2<_Fp, _A0>>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
noexcept(noexcept((__a0.get().*__f)(static_cast<_Args&&>(__args)...)))
-> decltype( (__a0.get().*__f)(static_cast<_Args&&>(__args)...))
{ return (__a0.get().*__f)(static_cast<_Args&&>(__args)...); }
template <class _Fp, class _A0, class ..._Args,
class = __enable_if_bullet2<_Fp, _A0>>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR auto
__invoke_constexpr(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
noexcept(noexcept((__a0.get().*__f)(static_cast<_Args&&>(__args)...)))
-> decltype( (__a0.get().*__f)(static_cast<_Args&&>(__args)...))
{ return (__a0.get().*__f)(static_cast<_Args&&>(__args)...); }
template <class _Fp, class _A0, class ..._Args,
class = __enable_if_bullet3<_Fp, _A0>>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
noexcept(noexcept(((*static_cast<_A0&&>(__a0)).*__f)(static_cast<_Args&&>(__args)...)))
-> decltype( ((*static_cast<_A0&&>(__a0)).*__f)(static_cast<_Args&&>(__args)...))
{ return ((*static_cast<_A0&&>(__a0)).*__f)(static_cast<_Args&&>(__args)...); }
template <class _Fp, class _A0, class ..._Args,
class = __enable_if_bullet3<_Fp, _A0>>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR auto
__invoke_constexpr(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
noexcept(noexcept(((*static_cast<_A0&&>(__a0)).*__f)(static_cast<_Args&&>(__args)...)))
-> decltype( ((*static_cast<_A0&&>(__a0)).*__f)(static_cast<_Args&&>(__args)...))
{ return ((*static_cast<_A0&&>(__a0)).*__f)(static_cast<_Args&&>(__args)...); }
// bullets 4, 5 and 6
template <class _Fp, class _A0,
class = __enable_if_bullet4<_Fp, _A0>>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
__invoke(_Fp&& __f, _A0&& __a0)
noexcept(noexcept(static_cast<_A0&&>(__a0).*__f))
-> decltype( static_cast<_A0&&>(__a0).*__f)
{ return static_cast<_A0&&>(__a0).*__f; }
template <class _Fp, class _A0,
class = __enable_if_bullet4<_Fp, _A0>>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR auto
__invoke_constexpr(_Fp&& __f, _A0&& __a0)
noexcept(noexcept(static_cast<_A0&&>(__a0).*__f))
-> decltype( static_cast<_A0&&>(__a0).*__f)
{ return static_cast<_A0&&>(__a0).*__f; }
template <class _Fp, class _A0,
class = __enable_if_bullet5<_Fp, _A0>>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
__invoke(_Fp&& __f, _A0&& __a0)
noexcept(noexcept(__a0.get().*__f))
-> decltype( __a0.get().*__f)
{ return __a0.get().*__f; }
template <class _Fp, class _A0,
class = __enable_if_bullet5<_Fp, _A0>>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR auto
__invoke_constexpr(_Fp&& __f, _A0&& __a0)
noexcept(noexcept(__a0.get().*__f))
-> decltype( __a0.get().*__f)
{ return __a0.get().*__f; }
template <class _Fp, class _A0,
class = __enable_if_bullet6<_Fp, _A0>>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
__invoke(_Fp&& __f, _A0&& __a0)
noexcept(noexcept((*static_cast<_A0&&>(__a0)).*__f))
-> decltype( (*static_cast<_A0&&>(__a0)).*__f)
{ return (*static_cast<_A0&&>(__a0)).*__f; }
template <class _Fp, class _A0,
class = __enable_if_bullet6<_Fp, _A0>>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR auto
__invoke_constexpr(_Fp&& __f, _A0&& __a0)
noexcept(noexcept((*static_cast<_A0&&>(__a0)).*__f))
-> decltype( (*static_cast<_A0&&>(__a0)).*__f)
{ return (*static_cast<_A0&&>(__a0)).*__f; }
// bullet 7
template <class _Fp, class ..._Args>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
__invoke(_Fp&& __f, _Args&& ...__args)
noexcept(noexcept(static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...)))
-> decltype( static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...))
{ return static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...); }
template <class _Fp, class ..._Args>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR auto
__invoke_constexpr(_Fp&& __f, _Args&& ...__args)
noexcept(noexcept(static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...)))
-> decltype( static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...))
{ return static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...); }
// __invokable
template <class _Ret, class _Fp, class ..._Args>
struct __invokable_r
{
template <class _XFp, class ..._XArgs>
static auto __try_call(int) -> decltype(
_VSTD::__invoke(declval<_XFp>(), declval<_XArgs>()...));
template <class _XFp, class ..._XArgs>
static __nat __try_call(...);
// FIXME: Check that _Ret, _Fp, and _Args... are all complete types, cv void,
// or incomplete array types as required by the standard.
using _Result = decltype(__try_call<_Fp, _Args...>(0));
using type =
typename conditional<
_IsNotSame<_Result, __nat>::value,
typename conditional<
is_void<_Ret>::value,
true_type,
is_convertible<_Result, _Ret>
>::type,
false_type
>::type;
static const bool value = type::value;
};
template <class _Fp, class ..._Args>
using __invokable = __invokable_r<void, _Fp, _Args...>;
template <bool _IsInvokable, bool _IsCVVoid, class _Ret, class _Fp, class ..._Args>
struct __nothrow_invokable_r_imp {
static const bool value = false;
};
template <class _Ret, class _Fp, class ..._Args>
struct __nothrow_invokable_r_imp<true, false, _Ret, _Fp, _Args...>
{
typedef __nothrow_invokable_r_imp _ThisT;
template <class _Tp>
static void __test_noexcept(_Tp) noexcept;
static const bool value = noexcept(_ThisT::__test_noexcept<_Ret>(
_VSTD::__invoke(declval<_Fp>(), declval<_Args>()...)));
};
template <class _Ret, class _Fp, class ..._Args>
struct __nothrow_invokable_r_imp<true, true, _Ret, _Fp, _Args...>
{
static const bool value = noexcept(
_VSTD::__invoke(declval<_Fp>(), declval<_Args>()...));
};
template <class _Ret, class _Fp, class ..._Args>
using __nothrow_invokable_r =
__nothrow_invokable_r_imp<
__invokable_r<_Ret, _Fp, _Args...>::value,
is_void<_Ret>::value,
_Ret, _Fp, _Args...
>;
template <class _Fp, class ..._Args>
using __nothrow_invokable =
__nothrow_invokable_r_imp<
__invokable<_Fp, _Args...>::value,
true, void, _Fp, _Args...
>;
template <class _Fp, class ..._Args>
struct __invoke_of
: public enable_if<
__invokable<_Fp, _Args...>::value,
typename __invokable_r<void, _Fp, _Args...>::_Result>
{
};
#endif // _LIBCPP_CXX03_LANG
// result_of
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
template <class _Callable> class _LIBCPP_DEPRECATED_IN_CXX17 result_of;
#ifndef _LIBCPP_CXX03_LANG
template <class _Fp, class ..._Args>
class _LIBCPP_TEMPLATE_VIS result_of<_Fp(_Args...)>
: public __invoke_of<_Fp, _Args...>
{
};
#else // C++03
template <class _Fn, bool, bool>
class __result_of
{
};
template <class _Fn, class ..._Args>
class __result_of<_Fn(_Args...), true, false>
{
public:
typedef decltype(declval<_Fn>()(declval<_Args>()...)) type;
};
template <class _MP, class _Tp, bool _IsMemberFunctionPtr>
struct __result_of_mp;
// member function pointer
template <class _MP, class _Tp>
struct __result_of_mp<_MP, _Tp, true>
{
using type = typename __member_pointer_traits<_MP>::_ReturnType;
};
// member data pointer
template <class _MP, class _Tp, bool>
struct __result_of_mdp;
template <class _Rp, class _Class, class _Tp>
struct __result_of_mdp<_Rp _Class::*, _Tp, false>
{
using type = typename __apply_cv<decltype(*declval<_Tp>()), _Rp>::type&;
};
template <class _Rp, class _Class, class _Tp>
struct __result_of_mdp<_Rp _Class::*, _Tp, true>
{
using type = typename __apply_cv<_Tp, _Rp>::type&;
};
template <class _Rp, class _Class, class _Tp>
struct __result_of_mp<_Rp _Class::*, _Tp, false>
: public __result_of_mdp<_Rp _Class::*, _Tp,
is_base_of<_Class, typename remove_reference<_Tp>::type>::value>
{
};
template <class _Fn, class _Tp>
class __result_of<_Fn(_Tp), false, true> // _Fn must be member pointer
: public __result_of_mp<typename remove_reference<_Fn>::type,
_Tp,
is_member_function_pointer<typename remove_reference<_Fn>::type>::value>
{
};
template <class _Fn, class _Tp, class ..._Args>
class __result_of<_Fn(_Tp, _Args...), false, true> // _Fn must be member pointer
: public __result_of_mp<typename remove_reference<_Fn>::type,
_Tp,
is_member_function_pointer<typename remove_reference<_Fn>::type>::value>
{
};
template <class _Fn, class ..._Args>
class _LIBCPP_TEMPLATE_VIS result_of<_Fn(_Args...)>
: public __result_of<_Fn(_Args...),
is_class<typename remove_reference<_Fn>::type>::value ||
is_function<typename remove_pointer<typename remove_reference<_Fn>::type>::type>::value,
is_member_pointer<typename remove_reference<_Fn>::type>::value
>
{
};
#endif // C++03
#if _LIBCPP_STD_VER > 11
template <class _Tp> using result_of_t _LIBCPP_DEPRECATED_IN_CXX17 = typename result_of<_Tp>::type;
#endif // _LIBCPP_STD_VER > 11
#endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
#if _LIBCPP_STD_VER > 14
// invoke_result
template <class _Fn, class... _Args>
struct _LIBCPP_TEMPLATE_VIS invoke_result
: __invoke_of<_Fn, _Args...>
{
};
template <class _Fn, class... _Args>
using invoke_result_t = typename invoke_result<_Fn, _Args...>::type;
// is_invocable
template <class _Fn, class ..._Args>
struct _LIBCPP_TEMPLATE_VIS is_invocable
: integral_constant<bool, __invokable<_Fn, _Args...>::value> {};
template <class _Ret, class _Fn, class ..._Args>
struct _LIBCPP_TEMPLATE_VIS is_invocable_r
: integral_constant<bool, __invokable_r<_Ret, _Fn, _Args...>::value> {};
template <class _Fn, class ..._Args>
inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value;
template <class _Ret, class _Fn, class ..._Args>
inline constexpr bool is_invocable_r_v = is_invocable_r<_Ret, _Fn, _Args...>::value;
// is_nothrow_invocable
template <class _Fn, class ..._Args>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_invocable
: integral_constant<bool, __nothrow_invokable<_Fn, _Args...>::value> {};
template <class _Ret, class _Fn, class ..._Args>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_invocable_r
: integral_constant<bool, __nothrow_invokable_r<_Ret, _Fn, _Args...>::value> {};
template <class _Fn, class ..._Args>
inline constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<_Fn, _Args...>::value;
template <class _Ret, class _Fn, class ..._Args>
inline constexpr bool is_nothrow_invocable_r_v = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value;
#endif // _LIBCPP_STD_VER > 14
// __swappable
template <class _Tp> struct __is_swappable;
template <class _Tp> struct __is_nothrow_swappable;
#ifndef _LIBCPP_CXX03_LANG
template <class _Tp>
using __swap_result_t = typename enable_if<is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value>::type;
#else
template <class>
using __swap_result_t = void;
#endif
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_AFTER_CXX17 __swap_result_t<_Tp>
swap(_Tp& __x, _Tp& __y) _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value &&
is_nothrow_move_assignable<_Tp>::value);
template<class _Tp, size_t _Np>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
typename enable_if<
__is_swappable<_Tp>::value
>::type
swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value);
namespace __detail
{
// ALL generic swap overloads MUST already have a declaration available at this point.
template <class _Tp, class _Up = _Tp,
bool _NotVoid = !is_void<_Tp>::value && !is_void<_Up>::value>
struct __swappable_with
{
template <class _LHS, class _RHS>
static decltype(swap(declval<_LHS>(), declval<_RHS>()))
__test_swap(int);
template <class, class>
static __nat __test_swap(long);
// Extra parens are needed for the C++03 definition of decltype.
typedef decltype((__test_swap<_Tp, _Up>(0))) __swap1;
typedef decltype((__test_swap<_Up, _Tp>(0))) __swap2;
static const bool value = _IsNotSame<__swap1, __nat>::value
&& _IsNotSame<__swap2, __nat>::value;
};
template <class _Tp, class _Up>
struct __swappable_with<_Tp, _Up, false> : false_type {};
template <class _Tp, class _Up = _Tp, bool _Swappable = __swappable_with<_Tp, _Up>::value>
struct __nothrow_swappable_with {
static const bool value =
#ifndef _LIBCPP_HAS_NO_NOEXCEPT
noexcept(swap(declval<_Tp>(), declval<_Up>()))
&& noexcept(swap(declval<_Up>(), declval<_Tp>()));
#else
false;
#endif
};
template <class _Tp, class _Up>
struct __nothrow_swappable_with<_Tp, _Up, false> : false_type {};
} // namespace __detail
template <class _Tp>
struct __is_swappable
: public integral_constant<bool, __detail::__swappable_with<_Tp&>::value>
{
};
template <class _Tp>
struct __is_nothrow_swappable
: public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp&>::value>
{
};
#if _LIBCPP_STD_VER > 14
template <class _Tp, class _Up>
struct _LIBCPP_TEMPLATE_VIS is_swappable_with
: public integral_constant<bool, __detail::__swappable_with<_Tp, _Up>::value>
{
};
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_swappable
: public conditional<
__is_referenceable<_Tp>::value,
is_swappable_with<
typename add_lvalue_reference<_Tp>::type,
typename add_lvalue_reference<_Tp>::type>,
false_type
>::type
{
};
template <class _Tp, class _Up>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_swappable_with
: public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp, _Up>::value>
{
};
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_swappable
: public conditional<
__is_referenceable<_Tp>::value,
is_nothrow_swappable_with<
typename add_lvalue_reference<_Tp>::type,
typename add_lvalue_reference<_Tp>::type>,
false_type
>::type
{
};
template <class _Tp, class _Up>
inline constexpr bool is_swappable_with_v = is_swappable_with<_Tp, _Up>::value;
template <class _Tp>
inline constexpr bool is_swappable_v = is_swappable<_Tp>::value;
template <class _Tp, class _Up>
inline constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<_Tp, _Up>::value;
template <class _Tp>
inline constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<_Tp>::value;
#endif // _LIBCPP_STD_VER > 14
template <class _Tp, bool = is_enum<_Tp>::value> struct __underlying_type_impl;
template <class _Tp>
struct __underlying_type_impl<_Tp, false> {};
template <class _Tp>
struct __underlying_type_impl<_Tp, true>
{
typedef __underlying_type(_Tp) type;
};
template <class _Tp>
struct underlying_type : __underlying_type_impl<_Tp, is_enum<_Tp>::value> {};
#if _LIBCPP_STD_VER > 11
template <class _Tp> using underlying_type_t = typename underlying_type<_Tp>::type;
#endif
template <class _Tp, bool = is_enum<_Tp>::value>
struct __sfinae_underlying_type
{
typedef typename underlying_type<_Tp>::type type;
typedef decltype(((type)1) + 0) __promoted_type;
};
template <class _Tp>
struct __sfinae_underlying_type<_Tp, false> {};
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
int __convert_to_integral(int __val) { return __val; }
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
unsigned __convert_to_integral(unsigned __val) { return __val; }
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
long __convert_to_integral(long __val) { return __val; }
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
unsigned long __convert_to_integral(unsigned long __val) { return __val; }
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
long long __convert_to_integral(long long __val) { return __val; }
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
unsigned long long __convert_to_integral(unsigned long long __val) {return __val; }
template<typename _Fp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
typename enable_if<is_floating_point<_Fp>::value, long long>::type
__convert_to_integral(_Fp __val) { return __val; }
#ifndef _LIBCPP_HAS_NO_INT128
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
__int128_t __convert_to_integral(__int128_t __val) { return __val; }
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
__uint128_t __convert_to_integral(__uint128_t __val) { return __val; }
#endif
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
typename __sfinae_underlying_type<_Tp>::__promoted_type
__convert_to_integral(_Tp __val) { return __val; }
// is_scoped_enum [meta.unary.prop]
#if _LIBCPP_STD_VER > 20
template <class _Tp, bool = is_enum_v<_Tp> >
struct __is_scoped_enum_helper : false_type {};
template <class _Tp>
struct __is_scoped_enum_helper<_Tp, true>
: public bool_constant<!is_convertible_v<_Tp, underlying_type_t<_Tp> > > {};
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_scoped_enum
: public __is_scoped_enum_helper<_Tp> {};
template <class _Tp>
inline constexpr bool is_scoped_enum_v = is_scoped_enum<_Tp>::value;
#endif
#if _LIBCPP_STD_VER > 14
template <class... _Args>
struct conjunction : _And<_Args...> {};
template<class... _Args>
inline constexpr bool conjunction_v = conjunction<_Args...>::value;
template <class... _Args>
struct disjunction : _Or<_Args...> {};
template<class... _Args>
inline constexpr bool disjunction_v = disjunction<_Args...>::value;
template <class _Tp>
struct negation : _Not<_Tp> {};
template<class _Tp>
inline constexpr bool negation_v = negation<_Tp>::value;
#endif // _LIBCPP_STD_VER > 14
// These traits are used in __tree and __hash_table
struct __extract_key_fail_tag {};
struct __extract_key_self_tag {};
struct __extract_key_first_tag {};
template <class _ValTy, class _Key,
class _RawValTy = typename __unconstref<_ValTy>::type>
struct __can_extract_key
: conditional<_IsSame<_RawValTy, _Key>::value, __extract_key_self_tag,
__extract_key_fail_tag>::type {};
template <class _Pair, class _Key, class _First, class _Second>
struct __can_extract_key<_Pair, _Key, pair<_First, _Second> >
: conditional<_IsSame<typename remove_const<_First>::type, _Key>::value,
__extract_key_first_tag, __extract_key_fail_tag>::type {};
// __can_extract_map_key uses true_type/false_type instead of the tags.
// It returns true if _Key != _ContainerValueTy (the container is a map not a set)
// and _ValTy == _Key.
template <class _ValTy, class _Key, class _ContainerValueTy,
class _RawValTy = typename __unconstref<_ValTy>::type>
struct __can_extract_map_key
: integral_constant<bool, _IsSame<_RawValTy, _Key>::value> {};
// This specialization returns __extract_key_fail_tag for non-map containers
// because _Key == _ContainerValueTy
template <class _ValTy, class _Key, class _RawValTy>
struct __can_extract_map_key<_ValTy, _Key, _Key, _RawValTy>
: false_type {};
#if _LIBCPP_STD_VER > 17
_LIBCPP_INLINE_VISIBILITY
inline constexpr bool is_constant_evaluated() noexcept {
return __builtin_is_constant_evaluated();
}
#endif
inline _LIBCPP_CONSTEXPR
bool __libcpp_is_constant_evaluated() _NOEXCEPT { return __builtin_is_constant_evaluated(); }
template <class _CharT>
using _IsCharLikeType = _And<is_standard_layout<_CharT>, is_trivial<_CharT> >;
template<class _Tp>
using __make_const_lvalue_ref = const typename remove_reference<_Tp>::type&;
#if _LIBCPP_STD_VER > 17
template<bool _Const, class _Tp>
using __maybe_const = conditional_t<_Const, const _Tp, _Tp>;
#endif // _LIBCPP_STD_VER > 17
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_TYPE_TRAITS
diff --git a/contrib/llvm-project/libcxx/src/string.cpp b/contrib/llvm-project/libcxx/src/string.cpp
index 3c63f408240d..3cde2e9005ba 100644
--- a/contrib/llvm-project/libcxx/src/string.cpp
+++ b/contrib/llvm-project/libcxx/src/string.cpp
@@ -1,503 +1,514 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "string"
#include "charconv"
#include "cstdlib"
#include "cerrno"
#include "limits"
#include "stdexcept"
#include <stdio.h>
#include "__debug"
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
# include "cwchar"
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
-#ifndef _LIBCPP_ABI_NO_BASIC_STRING_BASE_CLASS
+#ifndef _LIBCPP_ABI_DO_NOT_EXPORT_BASIC_STRING_COMMON
+
+template <bool>
+struct __basic_string_common;
+
+// The struct isn't declared anymore in the headers. It's only here for ABI compatibility.
+template <>
+struct __basic_string_common<true> {
+ _LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void __throw_length_error() const;
+ _LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void __throw_out_of_range() const;
+};
+
void __basic_string_common<true>::__throw_length_error() const {
- _VSTD::__throw_length_error("basic_string");
+ std::__throw_length_error("basic_string");
}
-
void __basic_string_common<true>::__throw_out_of_range() const {
- _VSTD::__throw_out_of_range("basic_string");
+ std::__throw_out_of_range("basic_string");
}
-#endif
+
+#endif // _LIBCPP_ABI_DO_NOT_EXPORT_BASIC_STRING_COMMON
#define _LIBCPP_EXTERN_TEMPLATE_DEFINE(...) template __VA_ARGS__;
#ifdef _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
_LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, char)
# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, wchar_t)
# endif
#else
_LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, char)
# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, wchar_t)
# endif
#endif
#undef _LIBCPP_EXTERN_TEMPLATE_DEFINE
template string operator+<char, char_traits<char>, allocator<char> >(char const*, string const&);
namespace
{
template<typename T>
inline
void throw_helper( const string& msg )
{
#ifndef _LIBCPP_NO_EXCEPTIONS
throw T( msg );
#else
fprintf(stderr, "%s\n", msg.c_str());
_VSTD::abort();
#endif
}
inline
void throw_from_string_out_of_range( const string& func )
{
throw_helper<out_of_range>(func + ": out of range");
}
inline
void throw_from_string_invalid_arg( const string& func )
{
throw_helper<invalid_argument>(func + ": no conversion");
}
// as_integer
template<typename V, typename S, typename F>
inline
V
as_integer_helper(const string& func, const S& str, size_t* idx, int base, F f)
{
typename S::value_type* ptr = nullptr;
const typename S::value_type* const p = str.c_str();
typename remove_reference<decltype(errno)>::type errno_save = errno;
errno = 0;
V r = f(p, &ptr, base);
swap(errno, errno_save);
if (errno_save == ERANGE)
throw_from_string_out_of_range(func);
if (ptr == p)
throw_from_string_invalid_arg(func);
if (idx)
*idx = static_cast<size_t>(ptr - p);
return r;
}
template<typename V, typename S>
inline
V
as_integer(const string& func, const S& s, size_t* idx, int base);
// string
template<>
inline
int
as_integer(const string& func, const string& s, size_t* idx, int base )
{
// Use long as no Standard string to integer exists.
long r = as_integer_helper<long>( func, s, idx, base, strtol );
if (r < numeric_limits<int>::min() || numeric_limits<int>::max() < r)
throw_from_string_out_of_range(func);
return static_cast<int>(r);
}
template<>
inline
long
as_integer(const string& func, const string& s, size_t* idx, int base )
{
return as_integer_helper<long>( func, s, idx, base, strtol );
}
template<>
inline
unsigned long
as_integer( const string& func, const string& s, size_t* idx, int base )
{
return as_integer_helper<unsigned long>( func, s, idx, base, strtoul );
}
template<>
inline
long long
as_integer( const string& func, const string& s, size_t* idx, int base )
{
return as_integer_helper<long long>( func, s, idx, base, strtoll );
}
template<>
inline
unsigned long long
as_integer( const string& func, const string& s, size_t* idx, int base )
{
return as_integer_helper<unsigned long long>( func, s, idx, base, strtoull );
}
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
// wstring
template<>
inline
int
as_integer( const string& func, const wstring& s, size_t* idx, int base )
{
// Use long as no Stantard string to integer exists.
long r = as_integer_helper<long>( func, s, idx, base, wcstol );
if (r < numeric_limits<int>::min() || numeric_limits<int>::max() < r)
throw_from_string_out_of_range(func);
return static_cast<int>(r);
}
template<>
inline
long
as_integer( const string& func, const wstring& s, size_t* idx, int base )
{
return as_integer_helper<long>( func, s, idx, base, wcstol );
}
template<>
inline
unsigned long
as_integer( const string& func, const wstring& s, size_t* idx, int base )
{
return as_integer_helper<unsigned long>( func, s, idx, base, wcstoul );
}
template<>
inline
long long
as_integer( const string& func, const wstring& s, size_t* idx, int base )
{
return as_integer_helper<long long>( func, s, idx, base, wcstoll );
}
template<>
inline
unsigned long long
as_integer( const string& func, const wstring& s, size_t* idx, int base )
{
return as_integer_helper<unsigned long long>( func, s, idx, base, wcstoull );
}
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
// as_float
template<typename V, typename S, typename F>
inline
V
as_float_helper(const string& func, const S& str, size_t* idx, F f )
{
typename S::value_type* ptr = nullptr;
const typename S::value_type* const p = str.c_str();
typename remove_reference<decltype(errno)>::type errno_save = errno;
errno = 0;
V r = f(p, &ptr);
swap(errno, errno_save);
if (errno_save == ERANGE)
throw_from_string_out_of_range(func);
if (ptr == p)
throw_from_string_invalid_arg(func);
if (idx)
*idx = static_cast<size_t>(ptr - p);
return r;
}
template<typename V, typename S>
inline
V as_float( const string& func, const S& s, size_t* idx = nullptr );
template<>
inline
float
as_float( const string& func, const string& s, size_t* idx )
{
return as_float_helper<float>( func, s, idx, strtof );
}
template<>
inline
double
as_float(const string& func, const string& s, size_t* idx )
{
return as_float_helper<double>( func, s, idx, strtod );
}
template<>
inline
long double
as_float( const string& func, const string& s, size_t* idx )
{
return as_float_helper<long double>( func, s, idx, strtold );
}
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template<>
inline
float
as_float( const string& func, const wstring& s, size_t* idx )
{
return as_float_helper<float>( func, s, idx, wcstof );
}
template<>
inline
double
as_float( const string& func, const wstring& s, size_t* idx )
{
return as_float_helper<double>( func, s, idx, wcstod );
}
template<>
inline
long double
as_float( const string& func, const wstring& s, size_t* idx )
{
return as_float_helper<long double>( func, s, idx, wcstold );
}
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
} // unnamed namespace
int
stoi(const string& str, size_t* idx, int base)
{
return as_integer<int>( "stoi", str, idx, base );
}
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
int
stoi(const wstring& str, size_t* idx, int base)
{
return as_integer<int>( "stoi", str, idx, base );
}
#endif
long
stol(const string& str, size_t* idx, int base)
{
return as_integer<long>( "stol", str, idx, base );
}
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
long
stol(const wstring& str, size_t* idx, int base)
{
return as_integer<long>( "stol", str, idx, base );
}
#endif
unsigned long
stoul(const string& str, size_t* idx, int base)
{
return as_integer<unsigned long>( "stoul", str, idx, base );
}
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
unsigned long
stoul(const wstring& str, size_t* idx, int base)
{
return as_integer<unsigned long>( "stoul", str, idx, base );
}
#endif
long long
stoll(const string& str, size_t* idx, int base)
{
return as_integer<long long>( "stoll", str, idx, base );
}
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
long long
stoll(const wstring& str, size_t* idx, int base)
{
return as_integer<long long>( "stoll", str, idx, base );
}
#endif
unsigned long long
stoull(const string& str, size_t* idx, int base)
{
return as_integer<unsigned long long>( "stoull", str, idx, base );
}
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
unsigned long long
stoull(const wstring& str, size_t* idx, int base)
{
return as_integer<unsigned long long>( "stoull", str, idx, base );
}
#endif
float
stof(const string& str, size_t* idx)
{
return as_float<float>( "stof", str, idx );
}
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
float
stof(const wstring& str, size_t* idx)
{
return as_float<float>( "stof", str, idx );
}
#endif
double
stod(const string& str, size_t* idx)
{
return as_float<double>( "stod", str, idx );
}
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
double
stod(const wstring& str, size_t* idx)
{
return as_float<double>( "stod", str, idx );
}
#endif
long double
stold(const string& str, size_t* idx)
{
return as_float<long double>( "stold", str, idx );
}
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
long double
stold(const wstring& str, size_t* idx)
{
return as_float<long double>( "stold", str, idx );
}
#endif
// to_string
namespace
{
// as_string
template<typename S, typename P, typename V >
inline
S
as_string(P sprintf_like, S s, const typename S::value_type* fmt, V a)
{
typedef typename S::size_type size_type;
size_type available = s.size();
while (true)
{
int status = sprintf_like(&s[0], available + 1, fmt, a);
if ( status >= 0 )
{
size_type used = static_cast<size_type>(status);
if ( used <= available )
{
s.resize( used );
break;
}
available = used; // Assume this is advice of how much space we need.
}
else
available = available * 2 + 1;
s.resize(available);
}
return s;
}
template <class S>
struct initial_string;
template <>
struct initial_string<string>
{
string
operator()() const
{
string s;
s.resize(s.capacity());
return s;
}
};
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <>
struct initial_string<wstring>
{
wstring
operator()() const
{
wstring s(20, wchar_t());
s.resize(s.capacity());
return s;
}
};
typedef int (*wide_printf)(wchar_t* __restrict, size_t, const wchar_t*__restrict, ...);
inline
wide_printf
get_swprintf()
{
#ifndef _LIBCPP_MSVCRT
return swprintf;
#else
return static_cast<int (__cdecl*)(wchar_t* __restrict, size_t, const wchar_t*__restrict, ...)>(_snwprintf);
#endif
}
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <typename S, typename V>
S i_to_string(V v)
{
// numeric_limits::digits10 returns value less on 1 than desired for unsigned numbers.
// For example, for 1-byte unsigned value digits10 is 2 (999 can not be represented),
// so we need +1 here.
constexpr size_t bufsize = numeric_limits<V>::digits10 + 2; // +1 for minus, +1 for digits10
char buf[bufsize];
const auto res = to_chars(buf, buf + bufsize, v);
_LIBCPP_ASSERT(res.ec == errc(), "bufsize must be large enough to accomodate the value");
return S(buf, res.ptr);
}
} // unnamed namespace
string to_string (int val) { return i_to_string< string>(val); }
string to_string (long val) { return i_to_string< string>(val); }
string to_string (long long val) { return i_to_string< string>(val); }
string to_string (unsigned val) { return i_to_string< string>(val); }
string to_string (unsigned long val) { return i_to_string< string>(val); }
string to_string (unsigned long long val) { return i_to_string< string>(val); }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
wstring to_wstring(int val) { return i_to_string<wstring>(val); }
wstring to_wstring(long val) { return i_to_string<wstring>(val); }
wstring to_wstring(long long val) { return i_to_string<wstring>(val); }
wstring to_wstring(unsigned val) { return i_to_string<wstring>(val); }
wstring to_wstring(unsigned long val) { return i_to_string<wstring>(val); }
wstring to_wstring(unsigned long long val) { return i_to_string<wstring>(val); }
#endif
string to_string (float val) { return as_string(snprintf, initial_string< string>()(), "%f", val); }
string to_string (double val) { return as_string(snprintf, initial_string< string>()(), "%f", val); }
string to_string (long double val) { return as_string(snprintf, initial_string< string>()(), "%Lf", val); }
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
wstring to_wstring(float val) { return as_string(get_swprintf(), initial_string<wstring>()(), L"%f", val); }
wstring to_wstring(double val) { return as_string(get_swprintf(), initial_string<wstring>()(), L"%f", val); }
wstring to_wstring(long double val) { return as_string(get_swprintf(), initial_string<wstring>()(), L"%Lf", val); }
#endif
_LIBCPP_END_NAMESPACE_STD
diff --git a/contrib/llvm-project/libunwind/src/DwarfInstructions.hpp b/contrib/llvm-project/libunwind/src/DwarfInstructions.hpp
index 6c21bc01c46e..b21da06d8778 100644
--- a/contrib/llvm-project/libunwind/src/DwarfInstructions.hpp
+++ b/contrib/llvm-project/libunwind/src/DwarfInstructions.hpp
@@ -1,846 +1,844 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//
// Processor specific interpretation of DWARF unwind info.
//
//===----------------------------------------------------------------------===//
#ifndef __DWARF_INSTRUCTIONS_HPP__
#define __DWARF_INSTRUCTIONS_HPP__
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include "dwarf2.h"
#include "Registers.hpp"
#include "DwarfParser.hpp"
#include "config.h"
namespace libunwind {
/// DwarfInstructions maps abtract DWARF unwind instructions to a particular
/// architecture
template <typename A, typename R>
class DwarfInstructions {
public:
typedef typename A::pint_t pint_t;
typedef typename A::sint_t sint_t;
static int stepWithDwarf(A &addressSpace, pint_t pc, pint_t fdeStart,
R &registers, bool &isSignalFrame);
private:
enum {
DW_X86_64_RET_ADDR = 16
};
enum {
DW_X86_RET_ADDR = 8
};
typedef typename CFI_Parser<A>::RegisterLocation RegisterLocation;
typedef typename CFI_Parser<A>::PrologInfo PrologInfo;
typedef typename CFI_Parser<A>::FDE_Info FDE_Info;
typedef typename CFI_Parser<A>::CIE_Info CIE_Info;
static pint_t evaluateExpression(pint_t expression, A &addressSpace,
const R &registers,
pint_t initialStackValue);
static pint_t getSavedRegister(A &addressSpace, const R &registers,
pint_t cfa, const RegisterLocation &savedReg);
static double getSavedFloatRegister(A &addressSpace, const R &registers,
pint_t cfa, const RegisterLocation &savedReg);
static v128 getSavedVectorRegister(A &addressSpace, const R &registers,
pint_t cfa, const RegisterLocation &savedReg);
static pint_t getCFA(A &addressSpace, const PrologInfo &prolog,
const R &registers) {
if (prolog.cfaRegister != 0)
return (pint_t)((sint_t)registers.getRegister((int)prolog.cfaRegister) +
prolog.cfaRegisterOffset);
if (prolog.cfaExpression != 0)
return evaluateExpression((pint_t)prolog.cfaExpression, addressSpace,
registers, 0);
assert(0 && "getCFA(): unknown location");
__builtin_unreachable();
}
};
template <typename A, typename R>
typename A::pint_t DwarfInstructions<A, R>::getSavedRegister(
A &addressSpace, const R &registers, pint_t cfa,
const RegisterLocation &savedReg) {
switch (savedReg.location) {
case CFI_Parser<A>::kRegisterInCFA:
return (pint_t)addressSpace.getRegister(cfa + (pint_t)savedReg.value);
case CFI_Parser<A>::kRegisterAtExpression:
return (pint_t)addressSpace.getRegister(evaluateExpression(
(pint_t)savedReg.value, addressSpace, registers, cfa));
case CFI_Parser<A>::kRegisterIsExpression:
return evaluateExpression((pint_t)savedReg.value, addressSpace,
registers, cfa);
case CFI_Parser<A>::kRegisterInRegister:
return registers.getRegister((int)savedReg.value);
case CFI_Parser<A>::kRegisterUnused:
case CFI_Parser<A>::kRegisterOffsetFromCFA:
// FIX ME
break;
}
_LIBUNWIND_ABORT("unsupported restore location for register");
}
template <typename A, typename R>
double DwarfInstructions<A, R>::getSavedFloatRegister(
A &addressSpace, const R &registers, pint_t cfa,
const RegisterLocation &savedReg) {
switch (savedReg.location) {
case CFI_Parser<A>::kRegisterInCFA:
return addressSpace.getDouble(cfa + (pint_t)savedReg.value);
case CFI_Parser<A>::kRegisterAtExpression:
return addressSpace.getDouble(
evaluateExpression((pint_t)savedReg.value, addressSpace,
registers, cfa));
- case CFI_Parser<A>::kRegisterUndefined:
- return 0.0;
case CFI_Parser<A>::kRegisterInRegister:
#ifndef _LIBUNWIND_TARGET_ARM
return registers.getFloatRegister((int)savedReg.value);
#endif
case CFI_Parser<A>::kRegisterIsExpression:
case CFI_Parser<A>::kRegisterUnused:
case CFI_Parser<A>::kRegisterOffsetFromCFA:
// FIX ME
break;
}
_LIBUNWIND_ABORT("unsupported restore location for float register");
}
template <typename A, typename R>
v128 DwarfInstructions<A, R>::getSavedVectorRegister(
A &addressSpace, const R &registers, pint_t cfa,
const RegisterLocation &savedReg) {
switch (savedReg.location) {
case CFI_Parser<A>::kRegisterInCFA:
return addressSpace.getVector(cfa + (pint_t)savedReg.value);
case CFI_Parser<A>::kRegisterAtExpression:
return addressSpace.getVector(
evaluateExpression((pint_t)savedReg.value, addressSpace,
registers, cfa));
case CFI_Parser<A>::kRegisterIsExpression:
case CFI_Parser<A>::kRegisterUnused:
case CFI_Parser<A>::kRegisterOffsetFromCFA:
case CFI_Parser<A>::kRegisterInRegister:
// FIX ME
break;
}
_LIBUNWIND_ABORT("unsupported restore location for vector register");
}
template <typename A, typename R>
int DwarfInstructions<A, R>::stepWithDwarf(A &addressSpace, pint_t pc,
pint_t fdeStart, R &registers,
bool &isSignalFrame) {
FDE_Info fdeInfo;
CIE_Info cieInfo;
if (CFI_Parser<A>::decodeFDE(addressSpace, fdeStart, &fdeInfo,
&cieInfo) == NULL) {
PrologInfo prolog;
if (CFI_Parser<A>::parseFDEInstructions(addressSpace, fdeInfo, cieInfo, pc,
R::getArch(), &prolog)) {
// get pointer to cfa (architecture specific)
pint_t cfa = getCFA(addressSpace, prolog, registers);
// restore registers that DWARF says were saved
R newRegisters = registers;
// Typically, the CFA is the stack pointer at the call site in
// the previous frame. However, there are scenarios in which this is not
// true. For example, if we switched to a new stack. In that case, the
// value of the previous SP might be indicated by a CFI directive.
//
// We set the SP here to the CFA, allowing for it to be overridden
// by a CFI directive later on.
newRegisters.setSP(cfa);
pint_t returnAddress = 0;
const int lastReg = R::lastDwarfRegNum();
assert(static_cast<int>(CFI_Parser<A>::kMaxRegisterNumber) >= lastReg &&
"register range too large");
assert(lastReg >= (int)cieInfo.returnAddressRegister &&
"register range does not contain return address register");
for (int i = 0; i <= lastReg; ++i) {
if (prolog.savedRegisters[i].location !=
CFI_Parser<A>::kRegisterUnused) {
if (registers.validFloatRegister(i))
newRegisters.setFloatRegister(
i, getSavedFloatRegister(addressSpace, registers, cfa,
prolog.savedRegisters[i]));
else if (registers.validVectorRegister(i))
newRegisters.setVectorRegister(
i, getSavedVectorRegister(addressSpace, registers, cfa,
prolog.savedRegisters[i]));
else if (i == (int)cieInfo.returnAddressRegister)
returnAddress = getSavedRegister(addressSpace, registers, cfa,
prolog.savedRegisters[i]);
else if (registers.validRegister(i))
newRegisters.setRegister(
i, getSavedRegister(addressSpace, registers, cfa,
prolog.savedRegisters[i]));
else
return UNW_EBADREG;
}
}
isSignalFrame = cieInfo.isSignalFrame;
#if defined(_LIBUNWIND_TARGET_AARCH64)
// If the target is aarch64 then the return address may have been signed
// using the v8.3 pointer authentication extensions. The original
// return address needs to be authenticated before the return address is
// restored. autia1716 is used instead of autia as autia1716 assembles
// to a NOP on pre-v8.3a architectures.
if ((R::getArch() == REGISTERS_ARM64) &&
prolog.savedRegisters[UNW_AARCH64_RA_SIGN_STATE].value &&
returnAddress != 0) {
#if !defined(_LIBUNWIND_IS_NATIVE_ONLY)
return UNW_ECROSSRASIGNING;
#else
register unsigned long long x17 __asm("x17") = returnAddress;
register unsigned long long x16 __asm("x16") = cfa;
// These are the autia1716/autib1716 instructions. The hint instructions
// are used here as gcc does not assemble autia1716/autib1716 for pre
// armv8.3a targets.
if (cieInfo.addressesSignedWithBKey)
asm("hint 0xe" : "+r"(x17) : "r"(x16)); // autib1716
else
asm("hint 0xc" : "+r"(x17) : "r"(x16)); // autia1716
returnAddress = x17;
#endif
}
#endif
#if defined(_LIBUNWIND_IS_NATIVE_ONLY) && defined(_LIBUNWIND_TARGET_ARM) && \
defined(__ARM_FEATURE_PAUTH)
if ((R::getArch() == REGISTERS_ARM) &&
prolog.savedRegisters[UNW_ARM_RA_AUTH_CODE].value) {
pint_t pac =
getSavedRegister(addressSpace, registers, cfa,
prolog.savedRegisters[UNW_ARM_RA_AUTH_CODE]);
__asm__ __volatile__("autg %0, %1, %2"
:
: "r"(pac), "r"(returnAddress), "r"(cfa)
:);
}
#endif
#if defined(_LIBUNWIND_TARGET_SPARC)
if (R::getArch() == REGISTERS_SPARC) {
// Skip call site instruction and delay slot
returnAddress += 8;
// Skip unimp instruction if function returns a struct
if ((addressSpace.get32(returnAddress) & 0xC1C00000) == 0)
returnAddress += 4;
}
#endif
#if defined(_LIBUNWIND_TARGET_PPC64)
#define PPC64_ELFV1_R2_LOAD_INST_ENCODING 0xe8410028u // ld r2,40(r1)
#define PPC64_ELFV1_R2_OFFSET 40
#define PPC64_ELFV2_R2_LOAD_INST_ENCODING 0xe8410018u // ld r2,24(r1)
#define PPC64_ELFV2_R2_OFFSET 24
// If the instruction at return address is a TOC (r2) restore,
// then r2 was saved and needs to be restored.
// ELFv2 ABI specifies that the TOC Pointer must be saved at SP + 24,
// while in ELFv1 ABI it is saved at SP + 40.
if (R::getArch() == REGISTERS_PPC64 && returnAddress != 0) {
pint_t sp = newRegisters.getRegister(UNW_REG_SP);
pint_t r2 = 0;
switch (addressSpace.get32(returnAddress)) {
case PPC64_ELFV1_R2_LOAD_INST_ENCODING:
r2 = addressSpace.get64(sp + PPC64_ELFV1_R2_OFFSET);
break;
case PPC64_ELFV2_R2_LOAD_INST_ENCODING:
r2 = addressSpace.get64(sp + PPC64_ELFV2_R2_OFFSET);
break;
}
if (r2)
newRegisters.setRegister(UNW_PPC64_R2, r2);
}
#endif
// Return address is address after call site instruction, so setting IP to
// that does simualates a return.
newRegisters.setIP(returnAddress);
// Simulate the step by replacing the register set with the new ones.
registers = newRegisters;
return UNW_STEP_SUCCESS;
}
}
return UNW_EBADFRAME;
}
template <typename A, typename R>
typename A::pint_t
DwarfInstructions<A, R>::evaluateExpression(pint_t expression, A &addressSpace,
const R &registers,
pint_t initialStackValue) {
const bool log = false;
pint_t p = expression;
pint_t expressionEnd = expression + 20; // temp, until len read
pint_t length = (pint_t)addressSpace.getULEB128(p, expressionEnd);
expressionEnd = p + length;
if (log)
fprintf(stderr, "evaluateExpression(): length=%" PRIu64 "\n",
(uint64_t)length);
pint_t stack[100];
pint_t *sp = stack;
*(++sp) = initialStackValue;
while (p < expressionEnd) {
if (log) {
for (pint_t *t = sp; t > stack; --t) {
fprintf(stderr, "sp[] = 0x%" PRIx64 "\n", (uint64_t)(*t));
}
}
uint8_t opcode = addressSpace.get8(p++);
sint_t svalue, svalue2;
pint_t value;
uint32_t reg;
switch (opcode) {
case DW_OP_addr:
// push immediate address sized value
value = addressSpace.getP(p);
p += sizeof(pint_t);
*(++sp) = value;
if (log)
fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
break;
case DW_OP_deref:
// pop stack, dereference, push result
value = *sp--;
*(++sp) = addressSpace.getP(value);
if (log)
fprintf(stderr, "dereference 0x%" PRIx64 "\n", (uint64_t)value);
break;
case DW_OP_const1u:
// push immediate 1 byte value
value = addressSpace.get8(p);
p += 1;
*(++sp) = value;
if (log)
fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
break;
case DW_OP_const1s:
// push immediate 1 byte signed value
svalue = (int8_t) addressSpace.get8(p);
p += 1;
*(++sp) = (pint_t)svalue;
if (log)
fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue);
break;
case DW_OP_const2u:
// push immediate 2 byte value
value = addressSpace.get16(p);
p += 2;
*(++sp) = value;
if (log)
fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
break;
case DW_OP_const2s:
// push immediate 2 byte signed value
svalue = (int16_t) addressSpace.get16(p);
p += 2;
*(++sp) = (pint_t)svalue;
if (log)
fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue);
break;
case DW_OP_const4u:
// push immediate 4 byte value
value = addressSpace.get32(p);
p += 4;
*(++sp) = value;
if (log)
fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
break;
case DW_OP_const4s:
// push immediate 4 byte signed value
svalue = (int32_t)addressSpace.get32(p);
p += 4;
*(++sp) = (pint_t)svalue;
if (log)
fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue);
break;
case DW_OP_const8u:
// push immediate 8 byte value
value = (pint_t)addressSpace.get64(p);
p += 8;
*(++sp) = value;
if (log)
fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
break;
case DW_OP_const8s:
// push immediate 8 byte signed value
value = (pint_t)addressSpace.get64(p);
p += 8;
*(++sp) = value;
if (log)
fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
break;
case DW_OP_constu:
// push immediate ULEB128 value
value = (pint_t)addressSpace.getULEB128(p, expressionEnd);
*(++sp) = value;
if (log)
fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
break;
case DW_OP_consts:
// push immediate SLEB128 value
svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd);
*(++sp) = (pint_t)svalue;
if (log)
fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue);
break;
case DW_OP_dup:
// push top of stack
value = *sp;
*(++sp) = value;
if (log)
fprintf(stderr, "duplicate top of stack\n");
break;
case DW_OP_drop:
// pop
--sp;
if (log)
fprintf(stderr, "pop top of stack\n");
break;
case DW_OP_over:
// dup second
value = sp[-1];
*(++sp) = value;
if (log)
fprintf(stderr, "duplicate second in stack\n");
break;
case DW_OP_pick:
// pick from
reg = addressSpace.get8(p);
p += 1;
value = sp[-(int)reg];
*(++sp) = value;
if (log)
fprintf(stderr, "duplicate %d in stack\n", reg);
break;
case DW_OP_swap:
// swap top two
value = sp[0];
sp[0] = sp[-1];
sp[-1] = value;
if (log)
fprintf(stderr, "swap top of stack\n");
break;
case DW_OP_rot:
// rotate top three
value = sp[0];
sp[0] = sp[-1];
sp[-1] = sp[-2];
sp[-2] = value;
if (log)
fprintf(stderr, "rotate top three of stack\n");
break;
case DW_OP_xderef:
// pop stack, dereference, push result
value = *sp--;
*sp = *((pint_t*)value);
if (log)
fprintf(stderr, "x-dereference 0x%" PRIx64 "\n", (uint64_t)value);
break;
case DW_OP_abs:
svalue = (sint_t)*sp;
if (svalue < 0)
*sp = (pint_t)(-svalue);
if (log)
fprintf(stderr, "abs\n");
break;
case DW_OP_and:
value = *sp--;
*sp &= value;
if (log)
fprintf(stderr, "and\n");
break;
case DW_OP_div:
svalue = (sint_t)(*sp--);
svalue2 = (sint_t)*sp;
*sp = (pint_t)(svalue2 / svalue);
if (log)
fprintf(stderr, "div\n");
break;
case DW_OP_minus:
value = *sp--;
*sp = *sp - value;
if (log)
fprintf(stderr, "minus\n");
break;
case DW_OP_mod:
svalue = (sint_t)(*sp--);
svalue2 = (sint_t)*sp;
*sp = (pint_t)(svalue2 % svalue);
if (log)
fprintf(stderr, "module\n");
break;
case DW_OP_mul:
svalue = (sint_t)(*sp--);
svalue2 = (sint_t)*sp;
*sp = (pint_t)(svalue2 * svalue);
if (log)
fprintf(stderr, "mul\n");
break;
case DW_OP_neg:
*sp = 0 - *sp;
if (log)
fprintf(stderr, "neg\n");
break;
case DW_OP_not:
svalue = (sint_t)(*sp);
*sp = (pint_t)(~svalue);
if (log)
fprintf(stderr, "not\n");
break;
case DW_OP_or:
value = *sp--;
*sp |= value;
if (log)
fprintf(stderr, "or\n");
break;
case DW_OP_plus:
value = *sp--;
*sp += value;
if (log)
fprintf(stderr, "plus\n");
break;
case DW_OP_plus_uconst:
// pop stack, add uelb128 constant, push result
*sp += static_cast<pint_t>(addressSpace.getULEB128(p, expressionEnd));
if (log)
fprintf(stderr, "add constant\n");
break;
case DW_OP_shl:
value = *sp--;
*sp = *sp << value;
if (log)
fprintf(stderr, "shift left\n");
break;
case DW_OP_shr:
value = *sp--;
*sp = *sp >> value;
if (log)
fprintf(stderr, "shift left\n");
break;
case DW_OP_shra:
value = *sp--;
svalue = (sint_t)*sp;
*sp = (pint_t)(svalue >> value);
if (log)
fprintf(stderr, "shift left arithmetric\n");
break;
case DW_OP_xor:
value = *sp--;
*sp ^= value;
if (log)
fprintf(stderr, "xor\n");
break;
case DW_OP_skip:
svalue = (int16_t) addressSpace.get16(p);
p += 2;
p = (pint_t)((sint_t)p + svalue);
if (log)
fprintf(stderr, "skip %" PRIu64 "\n", (uint64_t)svalue);
break;
case DW_OP_bra:
svalue = (int16_t) addressSpace.get16(p);
p += 2;
if (*sp--)
p = (pint_t)((sint_t)p + svalue);
if (log)
fprintf(stderr, "bra %" PRIu64 "\n", (uint64_t)svalue);
break;
case DW_OP_eq:
value = *sp--;
*sp = (*sp == value);
if (log)
fprintf(stderr, "eq\n");
break;
case DW_OP_ge:
value = *sp--;
*sp = (*sp >= value);
if (log)
fprintf(stderr, "ge\n");
break;
case DW_OP_gt:
value = *sp--;
*sp = (*sp > value);
if (log)
fprintf(stderr, "gt\n");
break;
case DW_OP_le:
value = *sp--;
*sp = (*sp <= value);
if (log)
fprintf(stderr, "le\n");
break;
case DW_OP_lt:
value = *sp--;
*sp = (*sp < value);
if (log)
fprintf(stderr, "lt\n");
break;
case DW_OP_ne:
value = *sp--;
*sp = (*sp != value);
if (log)
fprintf(stderr, "ne\n");
break;
case DW_OP_lit0:
case DW_OP_lit1:
case DW_OP_lit2:
case DW_OP_lit3:
case DW_OP_lit4:
case DW_OP_lit5:
case DW_OP_lit6:
case DW_OP_lit7:
case DW_OP_lit8:
case DW_OP_lit9:
case DW_OP_lit10:
case DW_OP_lit11:
case DW_OP_lit12:
case DW_OP_lit13:
case DW_OP_lit14:
case DW_OP_lit15:
case DW_OP_lit16:
case DW_OP_lit17:
case DW_OP_lit18:
case DW_OP_lit19:
case DW_OP_lit20:
case DW_OP_lit21:
case DW_OP_lit22:
case DW_OP_lit23:
case DW_OP_lit24:
case DW_OP_lit25:
case DW_OP_lit26:
case DW_OP_lit27:
case DW_OP_lit28:
case DW_OP_lit29:
case DW_OP_lit30:
case DW_OP_lit31:
value = static_cast<pint_t>(opcode - DW_OP_lit0);
*(++sp) = value;
if (log)
fprintf(stderr, "push literal 0x%" PRIx64 "\n", (uint64_t)value);
break;
case DW_OP_reg0:
case DW_OP_reg1:
case DW_OP_reg2:
case DW_OP_reg3:
case DW_OP_reg4:
case DW_OP_reg5:
case DW_OP_reg6:
case DW_OP_reg7:
case DW_OP_reg8:
case DW_OP_reg9:
case DW_OP_reg10:
case DW_OP_reg11:
case DW_OP_reg12:
case DW_OP_reg13:
case DW_OP_reg14:
case DW_OP_reg15:
case DW_OP_reg16:
case DW_OP_reg17:
case DW_OP_reg18:
case DW_OP_reg19:
case DW_OP_reg20:
case DW_OP_reg21:
case DW_OP_reg22:
case DW_OP_reg23:
case DW_OP_reg24:
case DW_OP_reg25:
case DW_OP_reg26:
case DW_OP_reg27:
case DW_OP_reg28:
case DW_OP_reg29:
case DW_OP_reg30:
case DW_OP_reg31:
reg = static_cast<uint32_t>(opcode - DW_OP_reg0);
*(++sp) = registers.getRegister((int)reg);
if (log)
fprintf(stderr, "push reg %d\n", reg);
break;
case DW_OP_regx:
reg = static_cast<uint32_t>(addressSpace.getULEB128(p, expressionEnd));
*(++sp) = registers.getRegister((int)reg);
if (log)
fprintf(stderr, "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue);
break;
case DW_OP_breg0:
case DW_OP_breg1:
case DW_OP_breg2:
case DW_OP_breg3:
case DW_OP_breg4:
case DW_OP_breg5:
case DW_OP_breg6:
case DW_OP_breg7:
case DW_OP_breg8:
case DW_OP_breg9:
case DW_OP_breg10:
case DW_OP_breg11:
case DW_OP_breg12:
case DW_OP_breg13:
case DW_OP_breg14:
case DW_OP_breg15:
case DW_OP_breg16:
case DW_OP_breg17:
case DW_OP_breg18:
case DW_OP_breg19:
case DW_OP_breg20:
case DW_OP_breg21:
case DW_OP_breg22:
case DW_OP_breg23:
case DW_OP_breg24:
case DW_OP_breg25:
case DW_OP_breg26:
case DW_OP_breg27:
case DW_OP_breg28:
case DW_OP_breg29:
case DW_OP_breg30:
case DW_OP_breg31:
reg = static_cast<uint32_t>(opcode - DW_OP_breg0);
svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd);
svalue += static_cast<sint_t>(registers.getRegister((int)reg));
*(++sp) = (pint_t)(svalue);
if (log)
fprintf(stderr, "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue);
break;
case DW_OP_bregx:
reg = static_cast<uint32_t>(addressSpace.getULEB128(p, expressionEnd));
svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd);
svalue += static_cast<sint_t>(registers.getRegister((int)reg));
*(++sp) = (pint_t)(svalue);
if (log)
fprintf(stderr, "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue);
break;
case DW_OP_fbreg:
_LIBUNWIND_ABORT("DW_OP_fbreg not implemented");
break;
case DW_OP_piece:
_LIBUNWIND_ABORT("DW_OP_piece not implemented");
break;
case DW_OP_deref_size:
// pop stack, dereference, push result
value = *sp--;
switch (addressSpace.get8(p++)) {
case 1:
value = addressSpace.get8(value);
break;
case 2:
value = addressSpace.get16(value);
break;
case 4:
value = addressSpace.get32(value);
break;
case 8:
value = (pint_t)addressSpace.get64(value);
break;
default:
_LIBUNWIND_ABORT("DW_OP_deref_size with bad size");
}
*(++sp) = value;
if (log)
fprintf(stderr, "sized dereference 0x%" PRIx64 "\n", (uint64_t)value);
break;
case DW_OP_xderef_size:
case DW_OP_nop:
case DW_OP_push_object_addres:
case DW_OP_call2:
case DW_OP_call4:
case DW_OP_call_ref:
default:
_LIBUNWIND_ABORT("DWARF opcode not implemented");
}
}
if (log)
fprintf(stderr, "expression evaluates to 0x%" PRIx64 "\n", (uint64_t)*sp);
return *sp;
}
} // namespace libunwind
#endif // __DWARF_INSTRUCTIONS_HPP__
diff --git a/contrib/llvm-project/llvm/lib/Debuginfod/HTTPClient.cpp b/contrib/llvm-project/llvm/lib/Debuginfod/HTTPClient.cpp
index 65f457933b92..cba342c9b343 100644
--- a/contrib/llvm-project/llvm/lib/Debuginfod/HTTPClient.cpp
+++ b/contrib/llvm-project/llvm/lib/Debuginfod/HTTPClient.cpp
@@ -1,216 +1,217 @@
//===-- llvm/Debuginfod/HTTPClient.cpp - HTTP client library ----*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
///
/// \file
///
/// This file defines the methods of the HTTPRequest, HTTPClient, and
/// BufferedHTTPResponseHandler classes.
///
//===----------------------------------------------------------------------===//
#include "llvm/Debuginfod/HTTPClient.h"
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Errc.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/MemoryBuffer.h"
#ifdef LLVM_ENABLE_CURL
#include <curl/curl.h>
#endif
using namespace llvm;
HTTPRequest::HTTPRequest(StringRef Url) { this->Url = Url.str(); }
bool operator==(const HTTPRequest &A, const HTTPRequest &B) {
return A.Url == B.Url && A.Method == B.Method &&
A.FollowRedirects == B.FollowRedirects;
}
HTTPResponseHandler::~HTTPResponseHandler() = default;
static inline bool parseContentLengthHeader(StringRef LineRef,
size_t &ContentLength) {
// Content-Length is a mandatory header, and the only one we handle.
return LineRef.consume_front("Content-Length: ") &&
to_integer(LineRef.trim(), ContentLength, 10);
}
Error BufferedHTTPResponseHandler::handleHeaderLine(StringRef HeaderLine) {
if (ResponseBuffer.Body)
return Error::success();
size_t ContentLength;
if (parseContentLengthHeader(HeaderLine, ContentLength))
ResponseBuffer.Body =
WritableMemoryBuffer::getNewUninitMemBuffer(ContentLength);
return Error::success();
}
Error BufferedHTTPResponseHandler::handleBodyChunk(StringRef BodyChunk) {
if (!ResponseBuffer.Body)
return createStringError(errc::io_error,
"Unallocated response buffer. HTTP Body data "
"received before Content-Length header.");
if (Offset + BodyChunk.size() > ResponseBuffer.Body->getBufferSize())
return createStringError(errc::io_error,
"Content size exceeds buffer size.");
memcpy(ResponseBuffer.Body->getBufferStart() + Offset, BodyChunk.data(),
BodyChunk.size());
Offset += BodyChunk.size();
return Error::success();
}
Error BufferedHTTPResponseHandler::handleStatusCode(unsigned Code) {
ResponseBuffer.Code = Code;
return Error::success();
}
bool HTTPClient::IsInitialized = false;
class HTTPClientCleanup {
public:
~HTTPClientCleanup() { HTTPClient::cleanup(); }
};
static const HTTPClientCleanup Cleanup;
Expected<HTTPResponseBuffer> HTTPClient::perform(const HTTPRequest &Request) {
BufferedHTTPResponseHandler Handler;
if (Error Err = perform(Request, Handler))
return std::move(Err);
return std::move(Handler.ResponseBuffer);
}
Expected<HTTPResponseBuffer> HTTPClient::get(StringRef Url) {
HTTPRequest Request(Url);
return perform(Request);
}
#ifdef LLVM_ENABLE_CURL
bool HTTPClient::isAvailable() { return true; }
void HTTPClient::initialize() {
if (!IsInitialized) {
curl_global_init(CURL_GLOBAL_ALL);
IsInitialized = true;
}
}
void HTTPClient::cleanup() {
if (IsInitialized) {
curl_global_cleanup();
IsInitialized = false;
}
}
void HTTPClient::setTimeout(std::chrono::milliseconds Timeout) {
if (Timeout < std::chrono::milliseconds(0))
Timeout = std::chrono::milliseconds(0);
curl_easy_setopt(Curl, CURLOPT_TIMEOUT_MS, Timeout.count());
}
/// CurlHTTPRequest and the curl{Header,Write}Function are implementation
/// details used to work with Curl. Curl makes callbacks with a single
/// customizable pointer parameter.
struct CurlHTTPRequest {
CurlHTTPRequest(HTTPResponseHandler &Handler) : Handler(Handler) {}
void storeError(Error Err) {
ErrorState = joinErrors(std::move(Err), std::move(ErrorState));
}
HTTPResponseHandler &Handler;
llvm::Error ErrorState = Error::success();
};
static size_t curlHeaderFunction(char *Contents, size_t Size, size_t NMemb,
CurlHTTPRequest *CurlRequest) {
assert(Size == 1 && "The Size passed by libCURL to CURLOPT_HEADERFUNCTION "
"should always be 1.");
if (Error Err =
CurlRequest->Handler.handleHeaderLine(StringRef(Contents, NMemb))) {
CurlRequest->storeError(std::move(Err));
return 0;
}
return NMemb;
}
static size_t curlWriteFunction(char *Contents, size_t Size, size_t NMemb,
CurlHTTPRequest *CurlRequest) {
Size *= NMemb;
if (Error Err =
CurlRequest->Handler.handleBodyChunk(StringRef(Contents, Size))) {
CurlRequest->storeError(std::move(Err));
return 0;
}
return Size;
}
HTTPClient::HTTPClient() {
assert(IsInitialized &&
"Must call HTTPClient::initialize() at the beginning of main().");
if (Curl)
return;
- assert((Curl = curl_easy_init()) && "Curl could not be initialized.");
+ Curl = curl_easy_init();
+ assert(Curl && "Curl could not be initialized");
// Set the callback hooks.
curl_easy_setopt(Curl, CURLOPT_WRITEFUNCTION, curlWriteFunction);
curl_easy_setopt(Curl, CURLOPT_HEADERFUNCTION, curlHeaderFunction);
}
HTTPClient::~HTTPClient() { curl_easy_cleanup(Curl); }
Error HTTPClient::perform(const HTTPRequest &Request,
HTTPResponseHandler &Handler) {
if (Request.Method != HTTPMethod::GET)
return createStringError(errc::invalid_argument,
"Unsupported CURL request method.");
SmallString<128> Url = Request.Url;
curl_easy_setopt(Curl, CURLOPT_URL, Url.c_str());
curl_easy_setopt(Curl, CURLOPT_FOLLOWLOCATION, Request.FollowRedirects);
CurlHTTPRequest CurlRequest(Handler);
curl_easy_setopt(Curl, CURLOPT_WRITEDATA, &CurlRequest);
curl_easy_setopt(Curl, CURLOPT_HEADERDATA, &CurlRequest);
CURLcode CurlRes = curl_easy_perform(Curl);
if (CurlRes != CURLE_OK)
return joinErrors(std::move(CurlRequest.ErrorState),
createStringError(errc::io_error,
"curl_easy_perform() failed: %s\n",
curl_easy_strerror(CurlRes)));
if (CurlRequest.ErrorState)
return std::move(CurlRequest.ErrorState);
unsigned Code;
curl_easy_getinfo(Curl, CURLINFO_RESPONSE_CODE, &Code);
if (Error Err = Handler.handleStatusCode(Code))
return joinErrors(std::move(CurlRequest.ErrorState), std::move(Err));
return std::move(CurlRequest.ErrorState);
}
#else
HTTPClient::HTTPClient() = default;
HTTPClient::~HTTPClient() = default;
bool HTTPClient::isAvailable() { return false; }
void HTTPClient::initialize() {}
void HTTPClient::cleanup() {}
void HTTPClient::setTimeout(std::chrono::milliseconds Timeout) {}
Error HTTPClient::perform(const HTTPRequest &Request,
HTTPResponseHandler &Handler) {
llvm_unreachable("No HTTP Client implementation available.");
}
#endif
diff --git a/contrib/llvm-project/llvm/lib/ObjectYAML/ELFYAML.cpp b/contrib/llvm-project/llvm/lib/ObjectYAML/ELFYAML.cpp
index d597148b98ab..3d4cd4088e9f 100644
--- a/contrib/llvm-project/llvm/lib/ObjectYAML/ELFYAML.cpp
+++ b/contrib/llvm-project/llvm/lib/ObjectYAML/ELFYAML.cpp
@@ -1,1879 +1,1882 @@
//===- ELFYAML.cpp - ELF YAMLIO implementation ----------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines classes for handling the YAML representation of ELF.
//
//===----------------------------------------------------------------------===//
#include "llvm/ObjectYAML/ELFYAML.h"
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/MapVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/BinaryFormat/ELF.h"
#include "llvm/Support/ARMEHABI.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/MipsABIFlags.h"
#include "llvm/Support/YAMLTraits.h"
#include "llvm/Support/WithColor.h"
#include <cassert>
#include <cstdint>
namespace llvm {
ELFYAML::Chunk::~Chunk() = default;
namespace ELFYAML {
unsigned Object::getMachine() const {
if (Header.Machine)
return *Header.Machine;
return llvm::ELF::EM_NONE;
}
constexpr StringRef SectionHeaderTable::TypeStr;
} // namespace ELFYAML
namespace yaml {
void ScalarEnumerationTraits<ELFYAML::ELF_ET>::enumeration(
IO &IO, ELFYAML::ELF_ET &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(ET_NONE);
ECase(ET_REL);
ECase(ET_EXEC);
ECase(ET_DYN);
ECase(ET_CORE);
#undef ECase
IO.enumFallback<Hex16>(Value);
}
void ScalarEnumerationTraits<ELFYAML::ELF_PT>::enumeration(
IO &IO, ELFYAML::ELF_PT &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(PT_NULL);
ECase(PT_LOAD);
ECase(PT_DYNAMIC);
ECase(PT_INTERP);
ECase(PT_NOTE);
ECase(PT_SHLIB);
ECase(PT_PHDR);
ECase(PT_TLS);
ECase(PT_GNU_EH_FRAME);
ECase(PT_GNU_STACK);
ECase(PT_GNU_RELRO);
ECase(PT_GNU_PROPERTY);
#undef ECase
IO.enumFallback<Hex32>(Value);
}
void ScalarEnumerationTraits<ELFYAML::ELF_NT>::enumeration(
IO &IO, ELFYAML::ELF_NT &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
// Generic note types.
ECase(NT_VERSION);
ECase(NT_ARCH);
ECase(NT_GNU_BUILD_ATTRIBUTE_OPEN);
ECase(NT_GNU_BUILD_ATTRIBUTE_FUNC);
// Core note types.
ECase(NT_PRSTATUS);
ECase(NT_FPREGSET);
ECase(NT_PRPSINFO);
ECase(NT_TASKSTRUCT);
ECase(NT_AUXV);
ECase(NT_PSTATUS);
ECase(NT_FPREGS);
ECase(NT_PSINFO);
ECase(NT_LWPSTATUS);
ECase(NT_LWPSINFO);
ECase(NT_WIN32PSTATUS);
ECase(NT_PPC_VMX);
ECase(NT_PPC_VSX);
ECase(NT_PPC_TAR);
ECase(NT_PPC_PPR);
ECase(NT_PPC_DSCR);
ECase(NT_PPC_EBB);
ECase(NT_PPC_PMU);
ECase(NT_PPC_TM_CGPR);
ECase(NT_PPC_TM_CFPR);
ECase(NT_PPC_TM_CVMX);
ECase(NT_PPC_TM_CVSX);
ECase(NT_PPC_TM_SPR);
ECase(NT_PPC_TM_CTAR);
ECase(NT_PPC_TM_CPPR);
ECase(NT_PPC_TM_CDSCR);
ECase(NT_386_TLS);
ECase(NT_386_IOPERM);
ECase(NT_X86_XSTATE);
ECase(NT_S390_HIGH_GPRS);
ECase(NT_S390_TIMER);
ECase(NT_S390_TODCMP);
ECase(NT_S390_TODPREG);
ECase(NT_S390_CTRS);
ECase(NT_S390_PREFIX);
ECase(NT_S390_LAST_BREAK);
ECase(NT_S390_SYSTEM_CALL);
ECase(NT_S390_TDB);
ECase(NT_S390_VXRS_LOW);
ECase(NT_S390_VXRS_HIGH);
ECase(NT_S390_GS_CB);
ECase(NT_S390_GS_BC);
ECase(NT_ARM_VFP);
ECase(NT_ARM_TLS);
ECase(NT_ARM_HW_BREAK);
ECase(NT_ARM_HW_WATCH);
ECase(NT_ARM_SVE);
ECase(NT_ARM_PAC_MASK);
ECase(NT_FILE);
ECase(NT_PRXFPREG);
ECase(NT_SIGINFO);
// LLVM-specific notes.
ECase(NT_LLVM_HWASAN_GLOBALS);
// GNU note types
ECase(NT_GNU_ABI_TAG);
ECase(NT_GNU_HWCAP);
ECase(NT_GNU_BUILD_ID);
ECase(NT_GNU_GOLD_VERSION);
ECase(NT_GNU_PROPERTY_TYPE_0);
// FreeBSD note types.
ECase(NT_FREEBSD_ABI_TAG);
ECase(NT_FREEBSD_NOINIT_TAG);
ECase(NT_FREEBSD_ARCH_TAG);
ECase(NT_FREEBSD_FEATURE_CTL);
// FreeBSD core note types.
ECase(NT_FREEBSD_THRMISC);
ECase(NT_FREEBSD_PROCSTAT_PROC);
ECase(NT_FREEBSD_PROCSTAT_FILES);
ECase(NT_FREEBSD_PROCSTAT_VMMAP);
ECase(NT_FREEBSD_PROCSTAT_GROUPS);
ECase(NT_FREEBSD_PROCSTAT_UMASK);
ECase(NT_FREEBSD_PROCSTAT_RLIMIT);
ECase(NT_FREEBSD_PROCSTAT_OSREL);
ECase(NT_FREEBSD_PROCSTAT_PSSTRINGS);
ECase(NT_FREEBSD_PROCSTAT_AUXV);
// NetBSD core note types.
ECase(NT_NETBSDCORE_PROCINFO);
ECase(NT_NETBSDCORE_AUXV);
ECase(NT_NETBSDCORE_LWPSTATUS);
// OpenBSD core note types.
ECase(NT_OPENBSD_PROCINFO);
ECase(NT_OPENBSD_AUXV);
ECase(NT_OPENBSD_REGS);
ECase(NT_OPENBSD_FPREGS);
ECase(NT_OPENBSD_XFPREGS);
ECase(NT_OPENBSD_WCOOKIE);
// AMD specific notes. (Code Object V2)
ECase(NT_AMD_HSA_CODE_OBJECT_VERSION);
ECase(NT_AMD_HSA_HSAIL);
ECase(NT_AMD_HSA_ISA_VERSION);
ECase(NT_AMD_HSA_METADATA);
ECase(NT_AMD_HSA_ISA_NAME);
ECase(NT_AMD_PAL_METADATA);
// AMDGPU specific notes. (Code Object V3)
ECase(NT_AMDGPU_METADATA);
#undef ECase
IO.enumFallback<Hex32>(Value);
}
void ScalarEnumerationTraits<ELFYAML::ELF_EM>::enumeration(
IO &IO, ELFYAML::ELF_EM &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(EM_NONE);
ECase(EM_M32);
ECase(EM_SPARC);
ECase(EM_386);
ECase(EM_68K);
ECase(EM_88K);
ECase(EM_IAMCU);
ECase(EM_860);
ECase(EM_MIPS);
ECase(EM_S370);
ECase(EM_MIPS_RS3_LE);
ECase(EM_PARISC);
ECase(EM_VPP500);
ECase(EM_SPARC32PLUS);
ECase(EM_960);
ECase(EM_PPC);
ECase(EM_PPC64);
ECase(EM_S390);
ECase(EM_SPU);
ECase(EM_V800);
ECase(EM_FR20);
ECase(EM_RH32);
ECase(EM_RCE);
ECase(EM_ARM);
ECase(EM_ALPHA);
ECase(EM_SH);
ECase(EM_SPARCV9);
ECase(EM_TRICORE);
ECase(EM_ARC);
ECase(EM_H8_300);
ECase(EM_H8_300H);
ECase(EM_H8S);
ECase(EM_H8_500);
ECase(EM_IA_64);
ECase(EM_MIPS_X);
ECase(EM_COLDFIRE);
ECase(EM_68HC12);
ECase(EM_MMA);
ECase(EM_PCP);
ECase(EM_NCPU);
ECase(EM_NDR1);
ECase(EM_STARCORE);
ECase(EM_ME16);
ECase(EM_ST100);
ECase(EM_TINYJ);
ECase(EM_X86_64);
ECase(EM_PDSP);
ECase(EM_PDP10);
ECase(EM_PDP11);
ECase(EM_FX66);
ECase(EM_ST9PLUS);
ECase(EM_ST7);
ECase(EM_68HC16);
ECase(EM_68HC11);
ECase(EM_68HC08);
ECase(EM_68HC05);
ECase(EM_SVX);
ECase(EM_ST19);
ECase(EM_VAX);
ECase(EM_CRIS);
ECase(EM_JAVELIN);
ECase(EM_FIREPATH);
ECase(EM_ZSP);
ECase(EM_MMIX);
ECase(EM_HUANY);
ECase(EM_PRISM);
ECase(EM_AVR);
ECase(EM_FR30);
ECase(EM_D10V);
ECase(EM_D30V);
ECase(EM_V850);
ECase(EM_M32R);
ECase(EM_MN10300);
ECase(EM_MN10200);
ECase(EM_PJ);
ECase(EM_OPENRISC);
ECase(EM_ARC_COMPACT);
ECase(EM_XTENSA);
ECase(EM_VIDEOCORE);
ECase(EM_TMM_GPP);
ECase(EM_NS32K);
ECase(EM_TPC);
ECase(EM_SNP1K);
ECase(EM_ST200);
ECase(EM_IP2K);
ECase(EM_MAX);
ECase(EM_CR);
ECase(EM_F2MC16);
ECase(EM_MSP430);
ECase(EM_BLACKFIN);
ECase(EM_SE_C33);
ECase(EM_SEP);
ECase(EM_ARCA);
ECase(EM_UNICORE);
ECase(EM_EXCESS);
ECase(EM_DXP);
ECase(EM_ALTERA_NIOS2);
ECase(EM_CRX);
ECase(EM_XGATE);
ECase(EM_C166);
ECase(EM_M16C);
ECase(EM_DSPIC30F);
ECase(EM_CE);
ECase(EM_M32C);
ECase(EM_TSK3000);
ECase(EM_RS08);
ECase(EM_SHARC);
ECase(EM_ECOG2);
ECase(EM_SCORE7);
ECase(EM_DSP24);
ECase(EM_VIDEOCORE3);
ECase(EM_LATTICEMICO32);
ECase(EM_SE_C17);
ECase(EM_TI_C6000);
ECase(EM_TI_C2000);
ECase(EM_TI_C5500);
ECase(EM_MMDSP_PLUS);
ECase(EM_CYPRESS_M8C);
ECase(EM_R32C);
ECase(EM_TRIMEDIA);
ECase(EM_HEXAGON);
ECase(EM_8051);
ECase(EM_STXP7X);
ECase(EM_NDS32);
ECase(EM_ECOG1);
ECase(EM_ECOG1X);
ECase(EM_MAXQ30);
ECase(EM_XIMO16);
ECase(EM_MANIK);
ECase(EM_CRAYNV2);
ECase(EM_RX);
ECase(EM_METAG);
ECase(EM_MCST_ELBRUS);
ECase(EM_ECOG16);
ECase(EM_CR16);
ECase(EM_ETPU);
ECase(EM_SLE9X);
ECase(EM_L10M);
ECase(EM_K10M);
ECase(EM_AARCH64);
ECase(EM_AVR32);
ECase(EM_STM8);
ECase(EM_TILE64);
ECase(EM_TILEPRO);
ECase(EM_MICROBLAZE);
ECase(EM_CUDA);
ECase(EM_TILEGX);
ECase(EM_CLOUDSHIELD);
ECase(EM_COREA_1ST);
ECase(EM_COREA_2ND);
ECase(EM_ARC_COMPACT2);
ECase(EM_OPEN8);
ECase(EM_RL78);
ECase(EM_VIDEOCORE5);
ECase(EM_78KOR);
ECase(EM_56800EX);
ECase(EM_AMDGPU);
ECase(EM_RISCV);
ECase(EM_LANAI);
ECase(EM_BPF);
ECase(EM_VE);
ECase(EM_CSKY);
#undef ECase
IO.enumFallback<Hex16>(Value);
}
void ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS>::enumeration(
IO &IO, ELFYAML::ELF_ELFCLASS &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
// Since the semantics of ELFCLASSNONE is "invalid", just don't accept it
// here.
ECase(ELFCLASS32);
ECase(ELFCLASS64);
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::ELF_ELFDATA>::enumeration(
IO &IO, ELFYAML::ELF_ELFDATA &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
// ELFDATANONE is an invalid data encoding, but we accept it because
// we want to be able to produce invalid binaries for the tests.
ECase(ELFDATANONE);
ECase(ELFDATA2LSB);
ECase(ELFDATA2MSB);
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::ELF_ELFOSABI>::enumeration(
IO &IO, ELFYAML::ELF_ELFOSABI &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(ELFOSABI_NONE);
ECase(ELFOSABI_HPUX);
ECase(ELFOSABI_NETBSD);
ECase(ELFOSABI_GNU);
ECase(ELFOSABI_LINUX);
ECase(ELFOSABI_HURD);
ECase(ELFOSABI_SOLARIS);
ECase(ELFOSABI_AIX);
ECase(ELFOSABI_IRIX);
ECase(ELFOSABI_FREEBSD);
ECase(ELFOSABI_TRU64);
ECase(ELFOSABI_MODESTO);
ECase(ELFOSABI_OPENBSD);
ECase(ELFOSABI_OPENVMS);
ECase(ELFOSABI_NSK);
ECase(ELFOSABI_AROS);
ECase(ELFOSABI_FENIXOS);
ECase(ELFOSABI_CLOUDABI);
ECase(ELFOSABI_AMDGPU_HSA);
ECase(ELFOSABI_AMDGPU_PAL);
ECase(ELFOSABI_AMDGPU_MESA3D);
ECase(ELFOSABI_ARM);
ECase(ELFOSABI_C6000_ELFABI);
ECase(ELFOSABI_C6000_LINUX);
ECase(ELFOSABI_STANDALONE);
#undef ECase
IO.enumFallback<Hex8>(Value);
}
void ScalarBitSetTraits<ELFYAML::ELF_EF>::bitset(IO &IO,
ELFYAML::ELF_EF &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
#define BCaseMask(X, M) IO.maskedBitSetCase(Value, #X, ELF::X, ELF::M)
switch (Object->getMachine()) {
case ELF::EM_ARM:
BCase(EF_ARM_SOFT_FLOAT);
BCase(EF_ARM_VFP_FLOAT);
BCaseMask(EF_ARM_EABI_UNKNOWN, EF_ARM_EABIMASK);
BCaseMask(EF_ARM_EABI_VER1, EF_ARM_EABIMASK);
BCaseMask(EF_ARM_EABI_VER2, EF_ARM_EABIMASK);
BCaseMask(EF_ARM_EABI_VER3, EF_ARM_EABIMASK);
BCaseMask(EF_ARM_EABI_VER4, EF_ARM_EABIMASK);
BCaseMask(EF_ARM_EABI_VER5, EF_ARM_EABIMASK);
break;
case ELF::EM_MIPS:
BCase(EF_MIPS_NOREORDER);
BCase(EF_MIPS_PIC);
BCase(EF_MIPS_CPIC);
BCase(EF_MIPS_ABI2);
BCase(EF_MIPS_32BITMODE);
BCase(EF_MIPS_FP64);
BCase(EF_MIPS_NAN2008);
BCase(EF_MIPS_MICROMIPS);
BCase(EF_MIPS_ARCH_ASE_M16);
BCase(EF_MIPS_ARCH_ASE_MDMX);
BCaseMask(EF_MIPS_ABI_O32, EF_MIPS_ABI);
BCaseMask(EF_MIPS_ABI_O64, EF_MIPS_ABI);
BCaseMask(EF_MIPS_ABI_EABI32, EF_MIPS_ABI);
BCaseMask(EF_MIPS_ABI_EABI64, EF_MIPS_ABI);
BCaseMask(EF_MIPS_MACH_3900, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_4010, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_4100, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_4650, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_4120, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_4111, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_SB1, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_OCTEON, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_XLR, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_OCTEON2, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_OCTEON3, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_5400, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_5900, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_5500, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_9000, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_LS2E, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_LS2F, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_LS3A, EF_MIPS_MACH);
BCaseMask(EF_MIPS_ARCH_1, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_2, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_3, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_4, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_5, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_32, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_64, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_32R2, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_64R2, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_32R6, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_64R6, EF_MIPS_ARCH);
break;
case ELF::EM_HEXAGON:
BCaseMask(EF_HEXAGON_MACH_V2, EF_HEXAGON_MACH);
BCaseMask(EF_HEXAGON_MACH_V3, EF_HEXAGON_MACH);
BCaseMask(EF_HEXAGON_MACH_V4, EF_HEXAGON_MACH);
BCaseMask(EF_HEXAGON_MACH_V5, EF_HEXAGON_MACH);
BCaseMask(EF_HEXAGON_MACH_V55, EF_HEXAGON_MACH);
BCaseMask(EF_HEXAGON_MACH_V60, EF_HEXAGON_MACH);
BCaseMask(EF_HEXAGON_MACH_V62, EF_HEXAGON_MACH);
BCaseMask(EF_HEXAGON_MACH_V65, EF_HEXAGON_MACH);
BCaseMask(EF_HEXAGON_MACH_V66, EF_HEXAGON_MACH);
BCaseMask(EF_HEXAGON_MACH_V67, EF_HEXAGON_MACH);
BCaseMask(EF_HEXAGON_MACH_V67T, EF_HEXAGON_MACH);
BCaseMask(EF_HEXAGON_MACH_V68, EF_HEXAGON_MACH);
BCaseMask(EF_HEXAGON_MACH_V69, EF_HEXAGON_MACH);
BCaseMask(EF_HEXAGON_ISA_V2, EF_HEXAGON_ISA);
BCaseMask(EF_HEXAGON_ISA_V3, EF_HEXAGON_ISA);
BCaseMask(EF_HEXAGON_ISA_V4, EF_HEXAGON_ISA);
BCaseMask(EF_HEXAGON_ISA_V5, EF_HEXAGON_ISA);
BCaseMask(EF_HEXAGON_ISA_V55, EF_HEXAGON_ISA);
BCaseMask(EF_HEXAGON_ISA_V60, EF_HEXAGON_ISA);
BCaseMask(EF_HEXAGON_ISA_V62, EF_HEXAGON_ISA);
BCaseMask(EF_HEXAGON_ISA_V65, EF_HEXAGON_ISA);
BCaseMask(EF_HEXAGON_ISA_V66, EF_HEXAGON_ISA);
BCaseMask(EF_HEXAGON_ISA_V67, EF_HEXAGON_ISA);
BCaseMask(EF_HEXAGON_ISA_V68, EF_HEXAGON_ISA);
BCaseMask(EF_HEXAGON_ISA_V69, EF_HEXAGON_ISA);
break;
case ELF::EM_AVR:
BCaseMask(EF_AVR_ARCH_AVR1, EF_AVR_ARCH_MASK);
BCaseMask(EF_AVR_ARCH_AVR2, EF_AVR_ARCH_MASK);
BCaseMask(EF_AVR_ARCH_AVR25, EF_AVR_ARCH_MASK);
BCaseMask(EF_AVR_ARCH_AVR3, EF_AVR_ARCH_MASK);
BCaseMask(EF_AVR_ARCH_AVR31, EF_AVR_ARCH_MASK);
BCaseMask(EF_AVR_ARCH_AVR35, EF_AVR_ARCH_MASK);
BCaseMask(EF_AVR_ARCH_AVR4, EF_AVR_ARCH_MASK);
BCaseMask(EF_AVR_ARCH_AVR5, EF_AVR_ARCH_MASK);
BCaseMask(EF_AVR_ARCH_AVR51, EF_AVR_ARCH_MASK);
BCaseMask(EF_AVR_ARCH_AVR6, EF_AVR_ARCH_MASK);
BCaseMask(EF_AVR_ARCH_AVRTINY, EF_AVR_ARCH_MASK);
BCaseMask(EF_AVR_ARCH_XMEGA1, EF_AVR_ARCH_MASK);
BCaseMask(EF_AVR_ARCH_XMEGA2, EF_AVR_ARCH_MASK);
BCaseMask(EF_AVR_ARCH_XMEGA3, EF_AVR_ARCH_MASK);
BCaseMask(EF_AVR_ARCH_XMEGA4, EF_AVR_ARCH_MASK);
BCaseMask(EF_AVR_ARCH_XMEGA5, EF_AVR_ARCH_MASK);
BCaseMask(EF_AVR_ARCH_XMEGA6, EF_AVR_ARCH_MASK);
BCaseMask(EF_AVR_ARCH_XMEGA7, EF_AVR_ARCH_MASK);
BCase(EF_AVR_LINKRELAX_PREPARED);
break;
case ELF::EM_RISCV:
BCase(EF_RISCV_RVC);
BCaseMask(EF_RISCV_FLOAT_ABI_SOFT, EF_RISCV_FLOAT_ABI);
BCaseMask(EF_RISCV_FLOAT_ABI_SINGLE, EF_RISCV_FLOAT_ABI);
BCaseMask(EF_RISCV_FLOAT_ABI_DOUBLE, EF_RISCV_FLOAT_ABI);
BCaseMask(EF_RISCV_FLOAT_ABI_QUAD, EF_RISCV_FLOAT_ABI);
BCase(EF_RISCV_RVE);
BCase(EF_RISCV_TSO);
break;
case ELF::EM_AMDGPU:
BCaseMask(EF_AMDGPU_MACH_NONE, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_R600, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_R630, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_RS880, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_RV670, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_RV710, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_RV730, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_RV770, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_CEDAR, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_CYPRESS, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_JUNIPER, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_REDWOOD, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_SUMO, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_BARTS, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_CAICOS, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_CAYMAN, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_TURKS, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX600, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX601, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX602, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX700, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX701, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX702, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX703, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX704, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX705, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX801, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX802, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX803, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX805, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX810, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX900, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX902, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX904, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX906, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX908, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX909, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX90A, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX90C, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1010, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1011, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1012, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1013, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1030, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1031, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1032, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1033, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1034, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1035, EF_AMDGPU_MACH);
switch (Object->Header.ABIVersion) {
default:
// ELFOSABI_AMDGPU_PAL, ELFOSABI_AMDGPU_MESA3D support *_V3 flags.
LLVM_FALLTHROUGH;
case ELF::ELFABIVERSION_AMDGPU_HSA_V3:
BCase(EF_AMDGPU_FEATURE_XNACK_V3);
BCase(EF_AMDGPU_FEATURE_SRAMECC_V3);
break;
case ELF::ELFABIVERSION_AMDGPU_HSA_V4:
case ELF::ELFABIVERSION_AMDGPU_HSA_V5:
BCaseMask(EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4,
EF_AMDGPU_FEATURE_XNACK_V4);
BCaseMask(EF_AMDGPU_FEATURE_XNACK_ANY_V4,
EF_AMDGPU_FEATURE_XNACK_V4);
BCaseMask(EF_AMDGPU_FEATURE_XNACK_OFF_V4,
EF_AMDGPU_FEATURE_XNACK_V4);
BCaseMask(EF_AMDGPU_FEATURE_XNACK_ON_V4,
EF_AMDGPU_FEATURE_XNACK_V4);
BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4,
EF_AMDGPU_FEATURE_SRAMECC_V4);
BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_ANY_V4,
EF_AMDGPU_FEATURE_SRAMECC_V4);
BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_OFF_V4,
EF_AMDGPU_FEATURE_SRAMECC_V4);
BCaseMask(EF_AMDGPU_FEATURE_SRAMECC_ON_V4,
EF_AMDGPU_FEATURE_SRAMECC_V4);
break;
}
break;
default:
break;
}
#undef BCase
#undef BCaseMask
}
void ScalarEnumerationTraits<ELFYAML::ELF_SHT>::enumeration(
IO &IO, ELFYAML::ELF_SHT &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(SHT_NULL);
ECase(SHT_PROGBITS);
ECase(SHT_SYMTAB);
// FIXME: Issue a diagnostic with this information.
ECase(SHT_STRTAB);
ECase(SHT_RELA);
ECase(SHT_HASH);
ECase(SHT_DYNAMIC);
ECase(SHT_NOTE);
ECase(SHT_NOBITS);
ECase(SHT_REL);
ECase(SHT_SHLIB);
ECase(SHT_DYNSYM);
ECase(SHT_INIT_ARRAY);
ECase(SHT_FINI_ARRAY);
ECase(SHT_PREINIT_ARRAY);
ECase(SHT_GROUP);
ECase(SHT_SYMTAB_SHNDX);
ECase(SHT_RELR);
ECase(SHT_ANDROID_REL);
ECase(SHT_ANDROID_RELA);
ECase(SHT_ANDROID_RELR);
ECase(SHT_LLVM_ODRTAB);
ECase(SHT_LLVM_LINKER_OPTIONS);
ECase(SHT_LLVM_CALL_GRAPH_PROFILE);
ECase(SHT_LLVM_ADDRSIG);
ECase(SHT_LLVM_DEPENDENT_LIBRARIES);
ECase(SHT_LLVM_SYMPART);
ECase(SHT_LLVM_PART_EHDR);
ECase(SHT_LLVM_PART_PHDR);
ECase(SHT_LLVM_BB_ADDR_MAP);
ECase(SHT_GNU_ATTRIBUTES);
ECase(SHT_GNU_HASH);
ECase(SHT_GNU_verdef);
ECase(SHT_GNU_verneed);
ECase(SHT_GNU_versym);
switch (Object->getMachine()) {
case ELF::EM_ARM:
ECase(SHT_ARM_EXIDX);
ECase(SHT_ARM_PREEMPTMAP);
ECase(SHT_ARM_ATTRIBUTES);
ECase(SHT_ARM_DEBUGOVERLAY);
ECase(SHT_ARM_OVERLAYSECTION);
break;
case ELF::EM_HEXAGON:
ECase(SHT_HEX_ORDERED);
break;
case ELF::EM_X86_64:
ECase(SHT_X86_64_UNWIND);
break;
case ELF::EM_MIPS:
ECase(SHT_MIPS_REGINFO);
ECase(SHT_MIPS_OPTIONS);
ECase(SHT_MIPS_DWARF);
ECase(SHT_MIPS_ABIFLAGS);
break;
case ELF::EM_RISCV:
ECase(SHT_RISCV_ATTRIBUTES);
break;
case ELF::EM_MSP430:
ECase(SHT_MSP430_ATTRIBUTES);
break;
default:
// Nothing to do.
break;
}
#undef ECase
IO.enumFallback<Hex32>(Value);
}
void ScalarBitSetTraits<ELFYAML::ELF_PF>::bitset(IO &IO,
ELFYAML::ELF_PF &Value) {
#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
BCase(PF_X);
BCase(PF_W);
BCase(PF_R);
}
void ScalarBitSetTraits<ELFYAML::ELF_SHF>::bitset(IO &IO,
ELFYAML::ELF_SHF &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
BCase(SHF_WRITE);
BCase(SHF_ALLOC);
BCase(SHF_EXCLUDE);
BCase(SHF_EXECINSTR);
BCase(SHF_MERGE);
BCase(SHF_STRINGS);
BCase(SHF_INFO_LINK);
BCase(SHF_LINK_ORDER);
BCase(SHF_OS_NONCONFORMING);
BCase(SHF_GROUP);
BCase(SHF_TLS);
BCase(SHF_COMPRESSED);
BCase(SHF_GNU_RETAIN);
switch (Object->getMachine()) {
case ELF::EM_ARM:
BCase(SHF_ARM_PURECODE);
break;
case ELF::EM_HEXAGON:
BCase(SHF_HEX_GPREL);
break;
case ELF::EM_MIPS:
BCase(SHF_MIPS_NODUPES);
BCase(SHF_MIPS_NAMES);
BCase(SHF_MIPS_LOCAL);
BCase(SHF_MIPS_NOSTRIP);
BCase(SHF_MIPS_GPREL);
BCase(SHF_MIPS_MERGE);
BCase(SHF_MIPS_ADDR);
BCase(SHF_MIPS_STRING);
break;
case ELF::EM_X86_64:
BCase(SHF_X86_64_LARGE);
break;
default:
// Nothing to do.
break;
}
#undef BCase
}
void ScalarEnumerationTraits<ELFYAML::ELF_SHN>::enumeration(
IO &IO, ELFYAML::ELF_SHN &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(SHN_UNDEF);
ECase(SHN_LORESERVE);
ECase(SHN_LOPROC);
ECase(SHN_HIPROC);
ECase(SHN_LOOS);
ECase(SHN_HIOS);
ECase(SHN_ABS);
ECase(SHN_COMMON);
ECase(SHN_XINDEX);
ECase(SHN_HIRESERVE);
ECase(SHN_AMDGPU_LDS);
ECase(SHN_HEXAGON_SCOMMON);
ECase(SHN_HEXAGON_SCOMMON_1);
ECase(SHN_HEXAGON_SCOMMON_2);
ECase(SHN_HEXAGON_SCOMMON_4);
ECase(SHN_HEXAGON_SCOMMON_8);
#undef ECase
IO.enumFallback<Hex16>(Value);
}
void ScalarEnumerationTraits<ELFYAML::ELF_STB>::enumeration(
IO &IO, ELFYAML::ELF_STB &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(STB_LOCAL);
ECase(STB_GLOBAL);
ECase(STB_WEAK);
ECase(STB_GNU_UNIQUE);
#undef ECase
IO.enumFallback<Hex8>(Value);
}
void ScalarEnumerationTraits<ELFYAML::ELF_STT>::enumeration(
IO &IO, ELFYAML::ELF_STT &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(STT_NOTYPE);
ECase(STT_OBJECT);
ECase(STT_FUNC);
ECase(STT_SECTION);
ECase(STT_FILE);
ECase(STT_COMMON);
ECase(STT_TLS);
ECase(STT_GNU_IFUNC);
#undef ECase
IO.enumFallback<Hex8>(Value);
}
void ScalarEnumerationTraits<ELFYAML::ELF_RSS>::enumeration(
IO &IO, ELFYAML::ELF_RSS &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(RSS_UNDEF);
ECase(RSS_GP);
ECase(RSS_GP0);
ECase(RSS_LOC);
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::ELF_REL>::enumeration(
IO &IO, ELFYAML::ELF_REL &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
#define ELF_RELOC(X, Y) IO.enumCase(Value, #X, ELF::X);
switch (Object->getMachine()) {
case ELF::EM_X86_64:
#include "llvm/BinaryFormat/ELFRelocs/x86_64.def"
break;
case ELF::EM_MIPS:
#include "llvm/BinaryFormat/ELFRelocs/Mips.def"
break;
case ELF::EM_HEXAGON:
#include "llvm/BinaryFormat/ELFRelocs/Hexagon.def"
break;
case ELF::EM_386:
case ELF::EM_IAMCU:
#include "llvm/BinaryFormat/ELFRelocs/i386.def"
break;
case ELF::EM_AARCH64:
#include "llvm/BinaryFormat/ELFRelocs/AArch64.def"
break;
case ELF::EM_ARM:
#include "llvm/BinaryFormat/ELFRelocs/ARM.def"
break;
case ELF::EM_ARC:
#include "llvm/BinaryFormat/ELFRelocs/ARC.def"
break;
case ELF::EM_RISCV:
#include "llvm/BinaryFormat/ELFRelocs/RISCV.def"
break;
case ELF::EM_LANAI:
#include "llvm/BinaryFormat/ELFRelocs/Lanai.def"
break;
case ELF::EM_AMDGPU:
#include "llvm/BinaryFormat/ELFRelocs/AMDGPU.def"
break;
case ELF::EM_BPF:
#include "llvm/BinaryFormat/ELFRelocs/BPF.def"
break;
case ELF::EM_VE:
#include "llvm/BinaryFormat/ELFRelocs/VE.def"
break;
case ELF::EM_CSKY:
#include "llvm/BinaryFormat/ELFRelocs/CSKY.def"
break;
+ case ELF::EM_PPC:
+#include "llvm/BinaryFormat/ELFRelocs/PowerPC.def"
+ break;
case ELF::EM_PPC64:
#include "llvm/BinaryFormat/ELFRelocs/PowerPC64.def"
break;
case ELF::EM_68K:
#include "llvm/BinaryFormat/ELFRelocs/M68k.def"
break;
default:
// Nothing to do.
break;
}
#undef ELF_RELOC
IO.enumFallback<Hex32>(Value);
}
void ScalarEnumerationTraits<ELFYAML::ELF_DYNTAG>::enumeration(
IO &IO, ELFYAML::ELF_DYNTAG &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
// Disable architecture specific tags by default. We might enable them below.
#define AARCH64_DYNAMIC_TAG(name, value)
#define MIPS_DYNAMIC_TAG(name, value)
#define HEXAGON_DYNAMIC_TAG(name, value)
#define PPC_DYNAMIC_TAG(name, value)
#define PPC64_DYNAMIC_TAG(name, value)
// Ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.
#define DYNAMIC_TAG_MARKER(name, value)
#define STRINGIFY(X) (#X)
#define DYNAMIC_TAG(X, Y) IO.enumCase(Value, STRINGIFY(DT_##X), ELF::DT_##X);
switch (Object->getMachine()) {
case ELF::EM_AARCH64:
#undef AARCH64_DYNAMIC_TAG
#define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
#include "llvm/BinaryFormat/DynamicTags.def"
#undef AARCH64_DYNAMIC_TAG
#define AARCH64_DYNAMIC_TAG(name, value)
break;
case ELF::EM_MIPS:
#undef MIPS_DYNAMIC_TAG
#define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
#include "llvm/BinaryFormat/DynamicTags.def"
#undef MIPS_DYNAMIC_TAG
#define MIPS_DYNAMIC_TAG(name, value)
break;
case ELF::EM_HEXAGON:
#undef HEXAGON_DYNAMIC_TAG
#define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
#include "llvm/BinaryFormat/DynamicTags.def"
#undef HEXAGON_DYNAMIC_TAG
#define HEXAGON_DYNAMIC_TAG(name, value)
break;
case ELF::EM_PPC:
#undef PPC_DYNAMIC_TAG
#define PPC_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
#include "llvm/BinaryFormat/DynamicTags.def"
#undef PPC_DYNAMIC_TAG
#define PPC_DYNAMIC_TAG(name, value)
break;
case ELF::EM_PPC64:
#undef PPC64_DYNAMIC_TAG
#define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
#include "llvm/BinaryFormat/DynamicTags.def"
#undef PPC64_DYNAMIC_TAG
#define PPC64_DYNAMIC_TAG(name, value)
break;
case ELF::EM_RISCV:
#undef RISCV_DYNAMIC_TAG
#define RISCV_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
#include "llvm/BinaryFormat/DynamicTags.def"
#undef RISCV_DYNAMIC_TAG
#define RISCV_DYNAMIC_TAG(name, value)
break;
default:
#include "llvm/BinaryFormat/DynamicTags.def"
break;
}
#undef AARCH64_DYNAMIC_TAG
#undef MIPS_DYNAMIC_TAG
#undef HEXAGON_DYNAMIC_TAG
#undef PPC_DYNAMIC_TAG
#undef PPC64_DYNAMIC_TAG
#undef DYNAMIC_TAG_MARKER
#undef STRINGIFY
#undef DYNAMIC_TAG
IO.enumFallback<Hex64>(Value);
}
void ScalarEnumerationTraits<ELFYAML::MIPS_AFL_REG>::enumeration(
IO &IO, ELFYAML::MIPS_AFL_REG &Value) {
#define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X)
ECase(REG_NONE);
ECase(REG_32);
ECase(REG_64);
ECase(REG_128);
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::MIPS_ABI_FP>::enumeration(
IO &IO, ELFYAML::MIPS_ABI_FP &Value) {
#define ECase(X) IO.enumCase(Value, #X, Mips::Val_GNU_MIPS_ABI_##X)
ECase(FP_ANY);
ECase(FP_DOUBLE);
ECase(FP_SINGLE);
ECase(FP_SOFT);
ECase(FP_OLD_64);
ECase(FP_XX);
ECase(FP_64);
ECase(FP_64A);
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::MIPS_AFL_EXT>::enumeration(
IO &IO, ELFYAML::MIPS_AFL_EXT &Value) {
#define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X)
ECase(EXT_NONE);
ECase(EXT_XLR);
ECase(EXT_OCTEON2);
ECase(EXT_OCTEONP);
ECase(EXT_LOONGSON_3A);
ECase(EXT_OCTEON);
ECase(EXT_5900);
ECase(EXT_4650);
ECase(EXT_4010);
ECase(EXT_4100);
ECase(EXT_3900);
ECase(EXT_10000);
ECase(EXT_SB1);
ECase(EXT_4111);
ECase(EXT_4120);
ECase(EXT_5400);
ECase(EXT_5500);
ECase(EXT_LOONGSON_2E);
ECase(EXT_LOONGSON_2F);
ECase(EXT_OCTEON3);
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::MIPS_ISA>::enumeration(
IO &IO, ELFYAML::MIPS_ISA &Value) {
IO.enumCase(Value, "MIPS1", 1);
IO.enumCase(Value, "MIPS2", 2);
IO.enumCase(Value, "MIPS3", 3);
IO.enumCase(Value, "MIPS4", 4);
IO.enumCase(Value, "MIPS5", 5);
IO.enumCase(Value, "MIPS32", 32);
IO.enumCase(Value, "MIPS64", 64);
IO.enumFallback<Hex32>(Value);
}
void ScalarBitSetTraits<ELFYAML::MIPS_AFL_ASE>::bitset(
IO &IO, ELFYAML::MIPS_AFL_ASE &Value) {
#define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_ASE_##X)
BCase(DSP);
BCase(DSPR2);
BCase(EVA);
BCase(MCU);
BCase(MDMX);
BCase(MIPS3D);
BCase(MT);
BCase(SMARTMIPS);
BCase(VIRT);
BCase(MSA);
BCase(MIPS16);
BCase(MICROMIPS);
BCase(XPA);
BCase(CRC);
BCase(GINV);
#undef BCase
}
void ScalarBitSetTraits<ELFYAML::MIPS_AFL_FLAGS1>::bitset(
IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value) {
#define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_FLAGS1_##X)
BCase(ODDSPREG);
#undef BCase
}
void MappingTraits<ELFYAML::SectionHeader>::mapping(
IO &IO, ELFYAML::SectionHeader &SHdr) {
IO.mapRequired("Name", SHdr.Name);
}
void MappingTraits<ELFYAML::FileHeader>::mapping(IO &IO,
ELFYAML::FileHeader &FileHdr) {
IO.mapRequired("Class", FileHdr.Class);
IO.mapRequired("Data", FileHdr.Data);
IO.mapOptional("OSABI", FileHdr.OSABI, ELFYAML::ELF_ELFOSABI(0));
IO.mapOptional("ABIVersion", FileHdr.ABIVersion, Hex8(0));
IO.mapRequired("Type", FileHdr.Type);
IO.mapOptional("Machine", FileHdr.Machine);
IO.mapOptional("Flags", FileHdr.Flags, ELFYAML::ELF_EF(0));
IO.mapOptional("Entry", FileHdr.Entry, Hex64(0));
IO.mapOptional("SectionHeaderStringTable", FileHdr.SectionHeaderStringTable);
// obj2yaml does not dump these fields.
assert(!IO.outputting() ||
(!FileHdr.EPhOff && !FileHdr.EPhEntSize && !FileHdr.EPhNum));
IO.mapOptional("EPhOff", FileHdr.EPhOff);
IO.mapOptional("EPhEntSize", FileHdr.EPhEntSize);
IO.mapOptional("EPhNum", FileHdr.EPhNum);
IO.mapOptional("EShEntSize", FileHdr.EShEntSize);
IO.mapOptional("EShOff", FileHdr.EShOff);
IO.mapOptional("EShNum", FileHdr.EShNum);
IO.mapOptional("EShStrNdx", FileHdr.EShStrNdx);
}
void MappingTraits<ELFYAML::ProgramHeader>::mapping(
IO &IO, ELFYAML::ProgramHeader &Phdr) {
IO.mapRequired("Type", Phdr.Type);
IO.mapOptional("Flags", Phdr.Flags, ELFYAML::ELF_PF(0));
IO.mapOptional("FirstSec", Phdr.FirstSec);
IO.mapOptional("LastSec", Phdr.LastSec);
IO.mapOptional("VAddr", Phdr.VAddr, Hex64(0));
IO.mapOptional("PAddr", Phdr.PAddr, Phdr.VAddr);
IO.mapOptional("Align", Phdr.Align);
IO.mapOptional("FileSize", Phdr.FileSize);
IO.mapOptional("MemSize", Phdr.MemSize);
IO.mapOptional("Offset", Phdr.Offset);
}
std::string MappingTraits<ELFYAML::ProgramHeader>::validate(
IO &IO, ELFYAML::ProgramHeader &FileHdr) {
if (!FileHdr.FirstSec && FileHdr.LastSec)
return "the \"LastSec\" key can't be used without the \"FirstSec\" key";
if (FileHdr.FirstSec && !FileHdr.LastSec)
return "the \"FirstSec\" key can't be used without the \"LastSec\" key";
return "";
}
LLVM_YAML_STRONG_TYPEDEF(StringRef, StOtherPiece)
template <> struct ScalarTraits<StOtherPiece> {
static void output(const StOtherPiece &Val, void *, raw_ostream &Out) {
Out << Val;
}
static StringRef input(StringRef Scalar, void *, StOtherPiece &Val) {
Val = Scalar;
return {};
}
static QuotingType mustQuote(StringRef) { return QuotingType::None; }
};
template <> struct SequenceElementTraits<StOtherPiece> {
static const bool flow = true;
};
template <> struct ScalarTraits<ELFYAML::YAMLFlowString> {
static void output(const ELFYAML::YAMLFlowString &Val, void *,
raw_ostream &Out) {
Out << Val;
}
static StringRef input(StringRef Scalar, void *,
ELFYAML::YAMLFlowString &Val) {
Val = Scalar;
return {};
}
static QuotingType mustQuote(StringRef S) {
return ScalarTraits<StringRef>::mustQuote(S);
}
};
template <> struct SequenceElementTraits<ELFYAML::YAMLFlowString> {
static const bool flow = true;
};
namespace {
struct NormalizedOther {
NormalizedOther(IO &IO) : YamlIO(IO) {}
NormalizedOther(IO &IO, Optional<uint8_t> Original) : YamlIO(IO) {
assert(Original && "This constructor is only used for outputting YAML and "
"assumes a non-empty Original");
std::vector<StOtherPiece> Ret;
const auto *Object = static_cast<ELFYAML::Object *>(YamlIO.getContext());
for (std::pair<StringRef, uint8_t> &P :
getFlags(Object->getMachine()).takeVector()) {
uint8_t FlagValue = P.second;
if ((*Original & FlagValue) != FlagValue)
continue;
*Original &= ~FlagValue;
Ret.push_back({P.first});
}
if (*Original != 0) {
UnknownFlagsHolder = std::to_string(*Original);
Ret.push_back({UnknownFlagsHolder});
}
if (!Ret.empty())
Other = std::move(Ret);
}
uint8_t toValue(StringRef Name) {
const auto *Object = static_cast<ELFYAML::Object *>(YamlIO.getContext());
MapVector<StringRef, uint8_t> Flags = getFlags(Object->getMachine());
auto It = Flags.find(Name);
if (It != Flags.end())
return It->second;
uint8_t Val;
if (to_integer(Name, Val))
return Val;
YamlIO.setError("an unknown value is used for symbol's 'Other' field: " +
Name);
return 0;
}
Optional<uint8_t> denormalize(IO &) {
if (!Other)
return None;
uint8_t Ret = 0;
for (StOtherPiece &Val : *Other)
Ret |= toValue(Val);
return Ret;
}
// st_other field is used to encode symbol visibility and platform-dependent
// flags and values. This method returns a name to value map that is used for
// parsing and encoding this field.
MapVector<StringRef, uint8_t> getFlags(unsigned EMachine) {
MapVector<StringRef, uint8_t> Map;
// STV_* values are just enumeration values. We add them in a reversed order
// because when we convert the st_other to named constants when printing
// YAML we want to use a maximum number of bits on each step:
// when we have st_other == 3, we want to print it as STV_PROTECTED (3), but
// not as STV_HIDDEN (2) + STV_INTERNAL (1).
Map["STV_PROTECTED"] = ELF::STV_PROTECTED;
Map["STV_HIDDEN"] = ELF::STV_HIDDEN;
Map["STV_INTERNAL"] = ELF::STV_INTERNAL;
// STV_DEFAULT is used to represent the default visibility and has a value
// 0. We want to be able to read it from YAML documents, but there is no
// reason to print it.
if (!YamlIO.outputting())
Map["STV_DEFAULT"] = ELF::STV_DEFAULT;
// MIPS is not consistent. All of the STO_MIPS_* values are bit flags,
// except STO_MIPS_MIPS16 which overlaps them. It should be checked and
// consumed first when we print the output, because we do not want to print
// any other flags that have the same bits instead.
if (EMachine == ELF::EM_MIPS) {
Map["STO_MIPS_MIPS16"] = ELF::STO_MIPS_MIPS16;
Map["STO_MIPS_MICROMIPS"] = ELF::STO_MIPS_MICROMIPS;
Map["STO_MIPS_PIC"] = ELF::STO_MIPS_PIC;
Map["STO_MIPS_PLT"] = ELF::STO_MIPS_PLT;
Map["STO_MIPS_OPTIONAL"] = ELF::STO_MIPS_OPTIONAL;
}
if (EMachine == ELF::EM_AARCH64)
Map["STO_AARCH64_VARIANT_PCS"] = ELF::STO_AARCH64_VARIANT_PCS;
if (EMachine == ELF::EM_RISCV)
Map["STO_RISCV_VARIANT_CC"] = ELF::STO_RISCV_VARIANT_CC;
return Map;
}
IO &YamlIO;
Optional<std::vector<StOtherPiece>> Other;
std::string UnknownFlagsHolder;
};
} // end anonymous namespace
void ScalarTraits<ELFYAML::YAMLIntUInt>::output(const ELFYAML::YAMLIntUInt &Val,
void *Ctx, raw_ostream &Out) {
Out << Val;
}
StringRef ScalarTraits<ELFYAML::YAMLIntUInt>::input(StringRef Scalar, void *Ctx,
ELFYAML::YAMLIntUInt &Val) {
const bool Is64 = static_cast<ELFYAML::Object *>(Ctx)->Header.Class ==
ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64);
StringRef ErrMsg = "invalid number";
// We do not accept negative hex numbers because their meaning is ambiguous.
// For example, would -0xfffffffff mean 1 or INT32_MIN?
if (Scalar.empty() || Scalar.startswith("-0x"))
return ErrMsg;
if (Scalar.startswith("-")) {
const int64_t MinVal = Is64 ? INT64_MIN : INT32_MIN;
long long Int;
if (getAsSignedInteger(Scalar, /*Radix=*/0, Int) || (Int < MinVal))
return ErrMsg;
Val = Int;
return "";
}
const uint64_t MaxVal = Is64 ? UINT64_MAX : UINT32_MAX;
unsigned long long UInt;
if (getAsUnsignedInteger(Scalar, /*Radix=*/0, UInt) || (UInt > MaxVal))
return ErrMsg;
Val = UInt;
return "";
}
void MappingTraits<ELFYAML::Symbol>::mapping(IO &IO, ELFYAML::Symbol &Symbol) {
IO.mapOptional("Name", Symbol.Name, StringRef());
IO.mapOptional("StName", Symbol.StName);
IO.mapOptional("Type", Symbol.Type, ELFYAML::ELF_STT(0));
IO.mapOptional("Section", Symbol.Section);
IO.mapOptional("Index", Symbol.Index);
IO.mapOptional("Binding", Symbol.Binding, ELFYAML::ELF_STB(0));
IO.mapOptional("Value", Symbol.Value);
IO.mapOptional("Size", Symbol.Size);
// Symbol's Other field is a bit special. It is usually a field that
// represents st_other and holds the symbol visibility. However, on some
// platforms, it can contain bit fields and regular values, or even sometimes a
// crazy mix of them (see comments for NormalizedOther). Because of this, we
// need special handling.
MappingNormalization<NormalizedOther, Optional<uint8_t>> Keys(IO,
Symbol.Other);
IO.mapOptional("Other", Keys->Other);
}
std::string MappingTraits<ELFYAML::Symbol>::validate(IO &IO,
ELFYAML::Symbol &Symbol) {
if (Symbol.Index && Symbol.Section)
return "Index and Section cannot both be specified for Symbol";
return "";
}
static void commonSectionMapping(IO &IO, ELFYAML::Section &Section) {
IO.mapOptional("Name", Section.Name, StringRef());
IO.mapRequired("Type", Section.Type);
IO.mapOptional("Flags", Section.Flags);
IO.mapOptional("Address", Section.Address);
IO.mapOptional("Link", Section.Link);
IO.mapOptional("AddressAlign", Section.AddressAlign, Hex64(0));
IO.mapOptional("EntSize", Section.EntSize);
IO.mapOptional("Offset", Section.Offset);
IO.mapOptional("Content", Section.Content);
IO.mapOptional("Size", Section.Size);
// obj2yaml does not dump these fields. They are expected to be empty when we
// are producing YAML, because yaml2obj sets appropriate values for them
// automatically when they are not explicitly defined.
assert(!IO.outputting() ||
(!Section.ShOffset && !Section.ShSize && !Section.ShName &&
!Section.ShFlags && !Section.ShType && !Section.ShAddrAlign));
IO.mapOptional("ShAddrAlign", Section.ShAddrAlign);
IO.mapOptional("ShName", Section.ShName);
IO.mapOptional("ShOffset", Section.ShOffset);
IO.mapOptional("ShSize", Section.ShSize);
IO.mapOptional("ShFlags", Section.ShFlags);
IO.mapOptional("ShType", Section.ShType);
}
static void sectionMapping(IO &IO, ELFYAML::DynamicSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Entries", Section.Entries);
}
static void sectionMapping(IO &IO, ELFYAML::RawContentSection &Section) {
commonSectionMapping(IO, Section);
// We also support reading a content as array of bytes using the ContentArray
// key. obj2yaml never prints this field.
assert(!IO.outputting() || !Section.ContentBuf.hasValue());
IO.mapOptional("ContentArray", Section.ContentBuf);
if (Section.ContentBuf) {
if (Section.Content)
IO.setError("Content and ContentArray can't be used together");
Section.Content = yaml::BinaryRef(*Section.ContentBuf);
}
IO.mapOptional("Info", Section.Info);
}
static void sectionMapping(IO &IO, ELFYAML::BBAddrMapSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Content", Section.Content);
IO.mapOptional("Entries", Section.Entries);
}
static void sectionMapping(IO &IO, ELFYAML::StackSizesSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Entries", Section.Entries);
}
static void sectionMapping(IO &IO, ELFYAML::HashSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Bucket", Section.Bucket);
IO.mapOptional("Chain", Section.Chain);
// obj2yaml does not dump these fields. They can be used to override nchain
// and nbucket values for creating broken sections.
assert(!IO.outputting() ||
(!Section.NBucket.hasValue() && !Section.NChain.hasValue()));
IO.mapOptional("NChain", Section.NChain);
IO.mapOptional("NBucket", Section.NBucket);
}
static void sectionMapping(IO &IO, ELFYAML::NoteSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Notes", Section.Notes);
}
static void sectionMapping(IO &IO, ELFYAML::GnuHashSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Header", Section.Header);
IO.mapOptional("BloomFilter", Section.BloomFilter);
IO.mapOptional("HashBuckets", Section.HashBuckets);
IO.mapOptional("HashValues", Section.HashValues);
}
static void sectionMapping(IO &IO, ELFYAML::NoBitsSection &Section) {
commonSectionMapping(IO, Section);
}
static void sectionMapping(IO &IO, ELFYAML::VerdefSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Info", Section.Info);
IO.mapOptional("Entries", Section.Entries);
}
static void sectionMapping(IO &IO, ELFYAML::SymverSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Entries", Section.Entries);
}
static void sectionMapping(IO &IO, ELFYAML::VerneedSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Info", Section.Info);
IO.mapOptional("Dependencies", Section.VerneedV);
}
static void sectionMapping(IO &IO, ELFYAML::RelocationSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Info", Section.RelocatableSec, StringRef());
IO.mapOptional("Relocations", Section.Relocations);
}
static void sectionMapping(IO &IO, ELFYAML::RelrSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Entries", Section.Entries);
}
static void groupSectionMapping(IO &IO, ELFYAML::GroupSection &Group) {
commonSectionMapping(IO, Group);
IO.mapOptional("Info", Group.Signature);
IO.mapOptional("Members", Group.Members);
}
static void sectionMapping(IO &IO, ELFYAML::SymtabShndxSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Entries", Section.Entries);
}
static void sectionMapping(IO &IO, ELFYAML::AddrsigSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Symbols", Section.Symbols);
}
static void fillMapping(IO &IO, ELFYAML::Fill &Fill) {
IO.mapOptional("Name", Fill.Name, StringRef());
IO.mapOptional("Pattern", Fill.Pattern);
IO.mapOptional("Offset", Fill.Offset);
IO.mapRequired("Size", Fill.Size);
}
static void sectionHeaderTableMapping(IO &IO,
ELFYAML::SectionHeaderTable &SHT) {
IO.mapOptional("Offset", SHT.Offset);
IO.mapOptional("Sections", SHT.Sections);
IO.mapOptional("Excluded", SHT.Excluded);
IO.mapOptional("NoHeaders", SHT.NoHeaders);
}
static void sectionMapping(IO &IO, ELFYAML::LinkerOptionsSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Options", Section.Options);
}
static void sectionMapping(IO &IO,
ELFYAML::DependentLibrariesSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Libraries", Section.Libs);
}
static void sectionMapping(IO &IO, ELFYAML::CallGraphProfileSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Entries", Section.Entries);
}
void MappingTraits<ELFYAML::SectionOrType>::mapping(
IO &IO, ELFYAML::SectionOrType &sectionOrType) {
IO.mapRequired("SectionOrType", sectionOrType.sectionNameOrType);
}
static void sectionMapping(IO &IO, ELFYAML::ARMIndexTableSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Entries", Section.Entries);
}
static void sectionMapping(IO &IO, ELFYAML::MipsABIFlags &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Version", Section.Version, Hex16(0));
IO.mapRequired("ISA", Section.ISALevel);
IO.mapOptional("ISARevision", Section.ISARevision, Hex8(0));
IO.mapOptional("ISAExtension", Section.ISAExtension,
ELFYAML::MIPS_AFL_EXT(Mips::AFL_EXT_NONE));
IO.mapOptional("ASEs", Section.ASEs, ELFYAML::MIPS_AFL_ASE(0));
IO.mapOptional("FpABI", Section.FpABI,
ELFYAML::MIPS_ABI_FP(Mips::Val_GNU_MIPS_ABI_FP_ANY));
IO.mapOptional("GPRSize", Section.GPRSize,
ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
IO.mapOptional("CPR1Size", Section.CPR1Size,
ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
IO.mapOptional("CPR2Size", Section.CPR2Size,
ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
IO.mapOptional("Flags1", Section.Flags1, ELFYAML::MIPS_AFL_FLAGS1(0));
IO.mapOptional("Flags2", Section.Flags2, Hex32(0));
}
static StringRef getStringValue(IO &IO, const char *Key) {
StringRef Val;
IO.mapRequired(Key, Val);
return Val;
}
static void setStringValue(IO &IO, const char *Key, StringRef Val) {
IO.mapRequired(Key, Val);
}
static bool isInteger(StringRef Val) {
APInt Tmp;
return !Val.getAsInteger(0, Tmp);
}
void MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::mapping(
IO &IO, std::unique_ptr<ELFYAML::Chunk> &Section) {
ELFYAML::ELF_SHT Type;
StringRef TypeStr;
if (IO.outputting()) {
if (auto *S = dyn_cast<ELFYAML::Section>(Section.get()))
Type = S->Type;
else if (auto *SHT = dyn_cast<ELFYAML::SectionHeaderTable>(Section.get()))
TypeStr = SHT->TypeStr;
} else {
// When the Type string does not have a "SHT_" prefix, we know it is not a
// description of a regular ELF output section.
TypeStr = getStringValue(IO, "Type");
if (TypeStr.startswith("SHT_") || isInteger(TypeStr))
IO.mapRequired("Type", Type);
}
if (TypeStr == "Fill") {
assert(!IO.outputting()); // We don't dump fills currently.
Section.reset(new ELFYAML::Fill());
fillMapping(IO, *cast<ELFYAML::Fill>(Section.get()));
return;
}
if (TypeStr == ELFYAML::SectionHeaderTable::TypeStr) {
if (IO.outputting())
setStringValue(IO, "Type", TypeStr);
else
Section.reset(new ELFYAML::SectionHeaderTable(/*IsImplicit=*/false));
sectionHeaderTableMapping(
IO, *cast<ELFYAML::SectionHeaderTable>(Section.get()));
return;
}
const auto &Obj = *static_cast<ELFYAML::Object *>(IO.getContext());
if (Obj.getMachine() == ELF::EM_MIPS && Type == ELF::SHT_MIPS_ABIFLAGS) {
if (!IO.outputting())
Section.reset(new ELFYAML::MipsABIFlags());
sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
return;
}
if (Obj.getMachine() == ELF::EM_ARM && Type == ELF::SHT_ARM_EXIDX) {
if (!IO.outputting())
Section.reset(new ELFYAML::ARMIndexTableSection());
sectionMapping(IO, *cast<ELFYAML::ARMIndexTableSection>(Section.get()));
return;
}
switch (Type) {
case ELF::SHT_DYNAMIC:
if (!IO.outputting())
Section.reset(new ELFYAML::DynamicSection());
sectionMapping(IO, *cast<ELFYAML::DynamicSection>(Section.get()));
break;
case ELF::SHT_REL:
case ELF::SHT_RELA:
if (!IO.outputting())
Section.reset(new ELFYAML::RelocationSection());
sectionMapping(IO, *cast<ELFYAML::RelocationSection>(Section.get()));
break;
case ELF::SHT_RELR:
if (!IO.outputting())
Section.reset(new ELFYAML::RelrSection());
sectionMapping(IO, *cast<ELFYAML::RelrSection>(Section.get()));
break;
case ELF::SHT_GROUP:
if (!IO.outputting())
Section.reset(new ELFYAML::GroupSection());
groupSectionMapping(IO, *cast<ELFYAML::GroupSection>(Section.get()));
break;
case ELF::SHT_NOBITS:
if (!IO.outputting())
Section.reset(new ELFYAML::NoBitsSection());
sectionMapping(IO, *cast<ELFYAML::NoBitsSection>(Section.get()));
break;
case ELF::SHT_HASH:
if (!IO.outputting())
Section.reset(new ELFYAML::HashSection());
sectionMapping(IO, *cast<ELFYAML::HashSection>(Section.get()));
break;
case ELF::SHT_NOTE:
if (!IO.outputting())
Section.reset(new ELFYAML::NoteSection());
sectionMapping(IO, *cast<ELFYAML::NoteSection>(Section.get()));
break;
case ELF::SHT_GNU_HASH:
if (!IO.outputting())
Section.reset(new ELFYAML::GnuHashSection());
sectionMapping(IO, *cast<ELFYAML::GnuHashSection>(Section.get()));
break;
case ELF::SHT_GNU_verdef:
if (!IO.outputting())
Section.reset(new ELFYAML::VerdefSection());
sectionMapping(IO, *cast<ELFYAML::VerdefSection>(Section.get()));
break;
case ELF::SHT_GNU_versym:
if (!IO.outputting())
Section.reset(new ELFYAML::SymverSection());
sectionMapping(IO, *cast<ELFYAML::SymverSection>(Section.get()));
break;
case ELF::SHT_GNU_verneed:
if (!IO.outputting())
Section.reset(new ELFYAML::VerneedSection());
sectionMapping(IO, *cast<ELFYAML::VerneedSection>(Section.get()));
break;
case ELF::SHT_SYMTAB_SHNDX:
if (!IO.outputting())
Section.reset(new ELFYAML::SymtabShndxSection());
sectionMapping(IO, *cast<ELFYAML::SymtabShndxSection>(Section.get()));
break;
case ELF::SHT_LLVM_ADDRSIG:
if (!IO.outputting())
Section.reset(new ELFYAML::AddrsigSection());
sectionMapping(IO, *cast<ELFYAML::AddrsigSection>(Section.get()));
break;
case ELF::SHT_LLVM_LINKER_OPTIONS:
if (!IO.outputting())
Section.reset(new ELFYAML::LinkerOptionsSection());
sectionMapping(IO, *cast<ELFYAML::LinkerOptionsSection>(Section.get()));
break;
case ELF::SHT_LLVM_DEPENDENT_LIBRARIES:
if (!IO.outputting())
Section.reset(new ELFYAML::DependentLibrariesSection());
sectionMapping(IO,
*cast<ELFYAML::DependentLibrariesSection>(Section.get()));
break;
case ELF::SHT_LLVM_CALL_GRAPH_PROFILE:
if (!IO.outputting())
Section.reset(new ELFYAML::CallGraphProfileSection());
sectionMapping(IO, *cast<ELFYAML::CallGraphProfileSection>(Section.get()));
break;
case ELF::SHT_LLVM_BB_ADDR_MAP:
if (!IO.outputting())
Section.reset(new ELFYAML::BBAddrMapSection());
sectionMapping(IO, *cast<ELFYAML::BBAddrMapSection>(Section.get()));
break;
default:
if (!IO.outputting()) {
StringRef Name;
IO.mapOptional("Name", Name, StringRef());
Name = ELFYAML::dropUniqueSuffix(Name);
if (ELFYAML::StackSizesSection::nameMatches(Name))
Section = std::make_unique<ELFYAML::StackSizesSection>();
else
Section = std::make_unique<ELFYAML::RawContentSection>();
}
if (auto S = dyn_cast<ELFYAML::RawContentSection>(Section.get()))
sectionMapping(IO, *S);
else
sectionMapping(IO, *cast<ELFYAML::StackSizesSection>(Section.get()));
}
}
std::string MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::validate(
IO &io, std::unique_ptr<ELFYAML::Chunk> &C) {
if (const auto *F = dyn_cast<ELFYAML::Fill>(C.get())) {
if (F->Pattern && F->Pattern->binary_size() != 0 && !F->Size)
return "\"Size\" can't be 0 when \"Pattern\" is not empty";
return "";
}
if (const auto *SHT = dyn_cast<ELFYAML::SectionHeaderTable>(C.get())) {
if (SHT->NoHeaders && (SHT->Sections || SHT->Excluded || SHT->Offset))
return "NoHeaders can't be used together with Offset/Sections/Excluded";
return "";
}
const ELFYAML::Section &Sec = *cast<ELFYAML::Section>(C.get());
if (Sec.Size && Sec.Content &&
(uint64_t)(*Sec.Size) < Sec.Content->binary_size())
return "Section size must be greater than or equal to the content size";
auto BuildErrPrefix = [](ArrayRef<std::pair<StringRef, bool>> EntV) {
std::string Msg;
for (size_t I = 0, E = EntV.size(); I != E; ++I) {
StringRef Name = EntV[I].first;
if (I == 0) {
Msg = "\"" + Name.str() + "\"";
continue;
}
if (I != EntV.size() - 1)
Msg += ", \"" + Name.str() + "\"";
else
Msg += " and \"" + Name.str() + "\"";
}
return Msg;
};
std::vector<std::pair<StringRef, bool>> Entries = Sec.getEntries();
const size_t NumUsedEntries = llvm::count_if(
Entries, [](const std::pair<StringRef, bool> &P) { return P.second; });
if ((Sec.Size || Sec.Content) && NumUsedEntries > 0)
return BuildErrPrefix(Entries) +
" cannot be used with \"Content\" or \"Size\"";
if (NumUsedEntries > 0 && Entries.size() != NumUsedEntries)
return BuildErrPrefix(Entries) + " must be used together";
if (const auto *RawSection = dyn_cast<ELFYAML::RawContentSection>(C.get())) {
if (RawSection->Flags && RawSection->ShFlags)
return "ShFlags and Flags cannot be used together";
return "";
}
if (const auto *NB = dyn_cast<ELFYAML::NoBitsSection>(C.get())) {
if (NB->Content)
return "SHT_NOBITS section cannot have \"Content\"";
return "";
}
if (const auto *MF = dyn_cast<ELFYAML::MipsABIFlags>(C.get())) {
if (MF->Content)
return "\"Content\" key is not implemented for SHT_MIPS_ABIFLAGS "
"sections";
if (MF->Size)
return "\"Size\" key is not implemented for SHT_MIPS_ABIFLAGS sections";
return "";
}
return "";
}
namespace {
struct NormalizedMips64RelType {
NormalizedMips64RelType(IO &)
: Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
Type2(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
Type3(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
SpecSym(ELFYAML::ELF_REL(ELF::RSS_UNDEF)) {}
NormalizedMips64RelType(IO &, ELFYAML::ELF_REL Original)
: Type(Original & 0xFF), Type2(Original >> 8 & 0xFF),
Type3(Original >> 16 & 0xFF), SpecSym(Original >> 24 & 0xFF) {}
ELFYAML::ELF_REL denormalize(IO &) {
ELFYAML::ELF_REL Res = Type | Type2 << 8 | Type3 << 16 | SpecSym << 24;
return Res;
}
ELFYAML::ELF_REL Type;
ELFYAML::ELF_REL Type2;
ELFYAML::ELF_REL Type3;
ELFYAML::ELF_RSS SpecSym;
};
} // end anonymous namespace
void MappingTraits<ELFYAML::StackSizeEntry>::mapping(
IO &IO, ELFYAML::StackSizeEntry &E) {
assert(IO.getContext() && "The IO context is not initialized");
IO.mapOptional("Address", E.Address, Hex64(0));
IO.mapRequired("Size", E.Size);
}
void MappingTraits<ELFYAML::BBAddrMapEntry>::mapping(
IO &IO, ELFYAML::BBAddrMapEntry &E) {
assert(IO.getContext() && "The IO context is not initialized");
IO.mapOptional("Address", E.Address, Hex64(0));
IO.mapOptional("NumBlocks", E.NumBlocks);
IO.mapOptional("BBEntries", E.BBEntries);
}
void MappingTraits<ELFYAML::BBAddrMapEntry::BBEntry>::mapping(
IO &IO, ELFYAML::BBAddrMapEntry::BBEntry &E) {
assert(IO.getContext() && "The IO context is not initialized");
IO.mapRequired("AddressOffset", E.AddressOffset);
IO.mapRequired("Size", E.Size);
IO.mapRequired("Metadata", E.Metadata);
}
void MappingTraits<ELFYAML::GnuHashHeader>::mapping(IO &IO,
ELFYAML::GnuHashHeader &E) {
assert(IO.getContext() && "The IO context is not initialized");
IO.mapOptional("NBuckets", E.NBuckets);
IO.mapRequired("SymNdx", E.SymNdx);
IO.mapOptional("MaskWords", E.MaskWords);
IO.mapRequired("Shift2", E.Shift2);
}
void MappingTraits<ELFYAML::DynamicEntry>::mapping(IO &IO,
ELFYAML::DynamicEntry &Rel) {
assert(IO.getContext() && "The IO context is not initialized");
IO.mapRequired("Tag", Rel.Tag);
IO.mapRequired("Value", Rel.Val);
}
void MappingTraits<ELFYAML::NoteEntry>::mapping(IO &IO, ELFYAML::NoteEntry &N) {
assert(IO.getContext() && "The IO context is not initialized");
IO.mapOptional("Name", N.Name);
IO.mapOptional("Desc", N.Desc);
IO.mapRequired("Type", N.Type);
}
void MappingTraits<ELFYAML::VerdefEntry>::mapping(IO &IO,
ELFYAML::VerdefEntry &E) {
assert(IO.getContext() && "The IO context is not initialized");
IO.mapOptional("Version", E.Version);
IO.mapOptional("Flags", E.Flags);
IO.mapOptional("VersionNdx", E.VersionNdx);
IO.mapOptional("Hash", E.Hash);
IO.mapRequired("Names", E.VerNames);
}
void MappingTraits<ELFYAML::VerneedEntry>::mapping(IO &IO,
ELFYAML::VerneedEntry &E) {
assert(IO.getContext() && "The IO context is not initialized");
IO.mapRequired("Version", E.Version);
IO.mapRequired("File", E.File);
IO.mapRequired("Entries", E.AuxV);
}
void MappingTraits<ELFYAML::VernauxEntry>::mapping(IO &IO,
ELFYAML::VernauxEntry &E) {
assert(IO.getContext() && "The IO context is not initialized");
IO.mapRequired("Name", E.Name);
IO.mapRequired("Hash", E.Hash);
IO.mapRequired("Flags", E.Flags);
IO.mapRequired("Other", E.Other);
}
void MappingTraits<ELFYAML::Relocation>::mapping(IO &IO,
ELFYAML::Relocation &Rel) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
IO.mapOptional("Offset", Rel.Offset, (Hex64)0);
IO.mapOptional("Symbol", Rel.Symbol);
if (Object->getMachine() == ELFYAML::ELF_EM(ELF::EM_MIPS) &&
Object->Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64)) {
MappingNormalization<NormalizedMips64RelType, ELFYAML::ELF_REL> Key(
IO, Rel.Type);
IO.mapRequired("Type", Key->Type);
IO.mapOptional("Type2", Key->Type2, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));
IO.mapOptional("Type3", Key->Type3, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));
IO.mapOptional("SpecSym", Key->SpecSym, ELFYAML::ELF_RSS(ELF::RSS_UNDEF));
} else
IO.mapRequired("Type", Rel.Type);
IO.mapOptional("Addend", Rel.Addend, (ELFYAML::YAMLIntUInt)0);
}
void MappingTraits<ELFYAML::ARMIndexTableEntry>::mapping(
IO &IO, ELFYAML::ARMIndexTableEntry &E) {
assert(IO.getContext() && "The IO context is not initialized");
IO.mapRequired("Offset", E.Offset);
StringRef CantUnwind = "EXIDX_CANTUNWIND";
if (IO.outputting() && (uint32_t)E.Value == ARM::EHABI::EXIDX_CANTUNWIND)
IO.mapRequired("Value", CantUnwind);
else if (!IO.outputting() && getStringValue(IO, "Value") == CantUnwind)
E.Value = ARM::EHABI::EXIDX_CANTUNWIND;
else
IO.mapRequired("Value", E.Value);
}
void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
assert(!IO.getContext() && "The IO context is initialized already");
IO.setContext(&Object);
IO.mapTag("!ELF", true);
IO.mapRequired("FileHeader", Object.Header);
IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
IO.mapOptional("Sections", Object.Chunks);
IO.mapOptional("Symbols", Object.Symbols);
IO.mapOptional("DynamicSymbols", Object.DynamicSymbols);
IO.mapOptional("DWARF", Object.DWARF);
if (Object.DWARF) {
Object.DWARF->IsLittleEndian =
Object.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
Object.DWARF->Is64BitAddrSize =
Object.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64);
}
IO.setContext(nullptr);
}
void MappingTraits<ELFYAML::LinkerOption>::mapping(IO &IO,
ELFYAML::LinkerOption &Opt) {
assert(IO.getContext() && "The IO context is not initialized");
IO.mapRequired("Name", Opt.Key);
IO.mapRequired("Value", Opt.Value);
}
void MappingTraits<ELFYAML::CallGraphEntryWeight>::mapping(
IO &IO, ELFYAML::CallGraphEntryWeight &E) {
assert(IO.getContext() && "The IO context is not initialized");
IO.mapRequired("Weight", E.Weight);
}
LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)
LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)
LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)
LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)
LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)
} // end namespace yaml
} // end namespace llvm
diff --git a/contrib/llvm-project/llvm/lib/Target/AVR/AVRFrameLowering.cpp b/contrib/llvm-project/llvm/lib/Target/AVR/AVRFrameLowering.cpp
index b3bc9ede205e..42a6e4f55dc8 100644
--- a/contrib/llvm-project/llvm/lib/Target/AVR/AVRFrameLowering.cpp
+++ b/contrib/llvm-project/llvm/lib/Target/AVR/AVRFrameLowering.cpp
@@ -1,481 +1,481 @@
//===-- AVRFrameLowering.cpp - AVR Frame Information ----------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file contains the AVR implementation of TargetFrameLowering class.
//
//===----------------------------------------------------------------------===//
#include "AVRFrameLowering.h"
#include "AVR.h"
#include "AVRInstrInfo.h"
#include "AVRMachineFunctionInfo.h"
#include "AVRTargetMachine.h"
#include "MCTargetDesc/AVRMCTargetDesc.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/IR/Function.h"
#include <vector>
namespace llvm {
AVRFrameLowering::AVRFrameLowering()
: TargetFrameLowering(TargetFrameLowering::StackGrowsDown, Align(1), -2) {}
bool AVRFrameLowering::canSimplifyCallFramePseudos(
const MachineFunction &MF) const {
// Always simplify call frame pseudo instructions, even when
// hasReservedCallFrame is false.
return true;
}
bool AVRFrameLowering::hasReservedCallFrame(const MachineFunction &MF) const {
// Reserve call frame memory in function prologue under the following
// conditions:
// - Y pointer is reserved to be the frame pointer.
// - The function does not contain variable sized objects.
const MachineFrameInfo &MFI = MF.getFrameInfo();
return hasFP(MF) && !MFI.hasVarSizedObjects();
}
void AVRFrameLowering::emitPrologue(MachineFunction &MF,
MachineBasicBlock &MBB) const {
MachineBasicBlock::iterator MBBI = MBB.begin();
DebugLoc DL = (MBBI != MBB.end()) ? MBBI->getDebugLoc() : DebugLoc();
const AVRSubtarget &STI = MF.getSubtarget<AVRSubtarget>();
const AVRInstrInfo &TII = *STI.getInstrInfo();
const AVRMachineFunctionInfo *AFI = MF.getInfo<AVRMachineFunctionInfo>();
bool HasFP = hasFP(MF);
// Interrupt handlers re-enable interrupts in function entry.
if (AFI->isInterruptHandler()) {
BuildMI(MBB, MBBI, DL, TII.get(AVR::BSETs))
.addImm(0x07)
.setMIFlag(MachineInstr::FrameSetup);
}
// Emit special prologue code to save R1, R0 and SREG in interrupt/signal
// handlers before saving any other registers.
if (AFI->isInterruptOrSignalHandler()) {
BuildMI(MBB, MBBI, DL, TII.get(AVR::PUSHWRr))
.addReg(AVR::R1R0, RegState::Kill)
.setMIFlag(MachineInstr::FrameSetup);
BuildMI(MBB, MBBI, DL, TII.get(AVR::INRdA), AVR::R0)
.addImm(0x3f)
.setMIFlag(MachineInstr::FrameSetup);
BuildMI(MBB, MBBI, DL, TII.get(AVR::PUSHRr))
.addReg(AVR::R0, RegState::Kill)
.setMIFlag(MachineInstr::FrameSetup);
BuildMI(MBB, MBBI, DL, TII.get(AVR::EORRdRr))
.addReg(AVR::R1, RegState::Define)
.addReg(AVR::R1, RegState::Kill)
.addReg(AVR::R1, RegState::Kill)
.setMIFlag(MachineInstr::FrameSetup);
}
// Early exit if the frame pointer is not needed in this function.
if (!HasFP) {
return;
}
const MachineFrameInfo &MFI = MF.getFrameInfo();
unsigned FrameSize = MFI.getStackSize() - AFI->getCalleeSavedFrameSize();
// Skip the callee-saved push instructions.
while (
(MBBI != MBB.end()) && MBBI->getFlag(MachineInstr::FrameSetup) &&
(MBBI->getOpcode() == AVR::PUSHRr || MBBI->getOpcode() == AVR::PUSHWRr)) {
++MBBI;
}
// Update Y with the new base value.
BuildMI(MBB, MBBI, DL, TII.get(AVR::SPREAD), AVR::R29R28)
.addReg(AVR::SP)
.setMIFlag(MachineInstr::FrameSetup);
// Mark the FramePtr as live-in in every block except the entry.
for (MachineBasicBlock &MBBJ : llvm::drop_begin(MF)) {
MBBJ.addLiveIn(AVR::R29R28);
}
if (!FrameSize) {
return;
}
// Reserve the necessary frame memory by doing FP -= <size>.
unsigned Opcode = (isUInt<6>(FrameSize)) ? AVR::SBIWRdK : AVR::SUBIWRdK;
MachineInstr *MI = BuildMI(MBB, MBBI, DL, TII.get(Opcode), AVR::R29R28)
.addReg(AVR::R29R28, RegState::Kill)
.addImm(FrameSize)
.setMIFlag(MachineInstr::FrameSetup);
// The SREG implicit def is dead.
MI->getOperand(3).setIsDead();
// Write back R29R28 to SP and temporarily disable interrupts.
BuildMI(MBB, MBBI, DL, TII.get(AVR::SPWRITE), AVR::SP)
.addReg(AVR::R29R28)
.setMIFlag(MachineInstr::FrameSetup);
}
static void restoreStatusRegister(MachineFunction &MF, MachineBasicBlock &MBB) {
const AVRMachineFunctionInfo *AFI = MF.getInfo<AVRMachineFunctionInfo>();
MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
DebugLoc DL = MBBI->getDebugLoc();
const AVRSubtarget &STI = MF.getSubtarget<AVRSubtarget>();
const AVRInstrInfo &TII = *STI.getInstrInfo();
// Emit special epilogue code to restore R1, R0 and SREG in interrupt/signal
// handlers at the very end of the function, just before reti.
if (AFI->isInterruptOrSignalHandler()) {
BuildMI(MBB, MBBI, DL, TII.get(AVR::POPRd), AVR::R0);
BuildMI(MBB, MBBI, DL, TII.get(AVR::OUTARr))
.addImm(0x3f)
.addReg(AVR::R0, RegState::Kill);
BuildMI(MBB, MBBI, DL, TII.get(AVR::POPWRd), AVR::R1R0);
}
}
void AVRFrameLowering::emitEpilogue(MachineFunction &MF,
MachineBasicBlock &MBB) const {
const AVRMachineFunctionInfo *AFI = MF.getInfo<AVRMachineFunctionInfo>();
// Early exit if the frame pointer is not needed in this function except for
// signal/interrupt handlers where special code generation is required.
if (!hasFP(MF) && !AFI->isInterruptOrSignalHandler()) {
return;
}
MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
assert(MBBI->getDesc().isReturn() &&
"Can only insert epilog into returning blocks");
DebugLoc DL = MBBI->getDebugLoc();
const MachineFrameInfo &MFI = MF.getFrameInfo();
unsigned FrameSize = MFI.getStackSize() - AFI->getCalleeSavedFrameSize();
const AVRSubtarget &STI = MF.getSubtarget<AVRSubtarget>();
const AVRInstrInfo &TII = *STI.getInstrInfo();
// Early exit if there is no need to restore the frame pointer.
if (!FrameSize && !MF.getFrameInfo().hasVarSizedObjects()) {
restoreStatusRegister(MF, MBB);
return;
}
// Skip the callee-saved pop instructions.
while (MBBI != MBB.begin()) {
MachineBasicBlock::iterator PI = std::prev(MBBI);
int Opc = PI->getOpcode();
if (Opc != AVR::POPRd && Opc != AVR::POPWRd && !PI->isTerminator()) {
break;
}
--MBBI;
}
if (FrameSize) {
unsigned Opcode;
// Select the optimal opcode depending on how big it is.
if (isUInt<6>(FrameSize)) {
Opcode = AVR::ADIWRdK;
} else {
Opcode = AVR::SUBIWRdK;
FrameSize = -FrameSize;
}
// Restore the frame pointer by doing FP += <size>.
MachineInstr *MI = BuildMI(MBB, MBBI, DL, TII.get(Opcode), AVR::R29R28)
.addReg(AVR::R29R28, RegState::Kill)
.addImm(FrameSize);
// The SREG implicit def is dead.
MI->getOperand(3).setIsDead();
}
// Write back R29R28 to SP and temporarily disable interrupts.
BuildMI(MBB, MBBI, DL, TII.get(AVR::SPWRITE), AVR::SP)
.addReg(AVR::R29R28, RegState::Kill);
restoreStatusRegister(MF, MBB);
}
// Return true if the specified function should have a dedicated frame
// pointer register. This is true if the function meets any of the following
// conditions:
// - a register has been spilled
// - has allocas
// - input arguments are passed using the stack
//
// Notice that strictly this is not a frame pointer because it contains SP after
// frame allocation instead of having the original SP in function entry.
bool AVRFrameLowering::hasFP(const MachineFunction &MF) const {
const AVRMachineFunctionInfo *FuncInfo = MF.getInfo<AVRMachineFunctionInfo>();
return (FuncInfo->getHasSpills() || FuncInfo->getHasAllocas() ||
FuncInfo->getHasStackArgs() ||
MF.getFrameInfo().hasVarSizedObjects());
}
bool AVRFrameLowering::spillCalleeSavedRegisters(
MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
ArrayRef<CalleeSavedInfo> CSI, const TargetRegisterInfo *TRI) const {
if (CSI.empty()) {
return false;
}
unsigned CalleeFrameSize = 0;
DebugLoc DL = MBB.findDebugLoc(MI);
MachineFunction &MF = *MBB.getParent();
const AVRSubtarget &STI = MF.getSubtarget<AVRSubtarget>();
const TargetInstrInfo &TII = *STI.getInstrInfo();
AVRMachineFunctionInfo *AVRFI = MF.getInfo<AVRMachineFunctionInfo>();
for (const CalleeSavedInfo &I : llvm::reverse(CSI)) {
Register Reg = I.getReg();
bool IsNotLiveIn = !MBB.isLiveIn(Reg);
assert(TRI->getRegSizeInBits(*TRI->getMinimalPhysRegClass(Reg)) == 8 &&
"Invalid register size");
// Add the callee-saved register as live-in only if it is not already a
// live-in register, this usually happens with arguments that are passed
// through callee-saved registers.
if (IsNotLiveIn) {
MBB.addLiveIn(Reg);
}
// Do not kill the register when it is an input argument.
BuildMI(MBB, MI, DL, TII.get(AVR::PUSHRr))
.addReg(Reg, getKillRegState(IsNotLiveIn))
.setMIFlag(MachineInstr::FrameSetup);
++CalleeFrameSize;
}
AVRFI->setCalleeSavedFrameSize(CalleeFrameSize);
return true;
}
bool AVRFrameLowering::restoreCalleeSavedRegisters(
MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
MutableArrayRef<CalleeSavedInfo> CSI, const TargetRegisterInfo *TRI) const {
if (CSI.empty()) {
return false;
}
DebugLoc DL = MBB.findDebugLoc(MI);
const MachineFunction &MF = *MBB.getParent();
const AVRSubtarget &STI = MF.getSubtarget<AVRSubtarget>();
const TargetInstrInfo &TII = *STI.getInstrInfo();
for (const CalleeSavedInfo &CCSI : CSI) {
Register Reg = CCSI.getReg();
assert(TRI->getRegSizeInBits(*TRI->getMinimalPhysRegClass(Reg)) == 8 &&
"Invalid register size");
BuildMI(MBB, MI, DL, TII.get(AVR::POPRd), Reg);
}
return true;
}
/// Replace pseudo store instructions that pass arguments through the stack with
/// real instructions.
static void fixStackStores(MachineBasicBlock &MBB,
- MachineBasicBlock::iterator MI,
+ MachineBasicBlock::iterator StartMI,
const TargetInstrInfo &TII, Register FP) {
// Iterate through the BB until we hit a call instruction or we reach the end.
for (MachineInstr &MI :
- llvm::make_early_inc_range(llvm::make_range(MI, MBB.end()))) {
+ llvm::make_early_inc_range(llvm::make_range(StartMI, MBB.end()))) {
if (MI.isCall())
break;
unsigned Opcode = MI.getOpcode();
// Only care of pseudo store instructions where SP is the base pointer.
if (Opcode != AVR::STDSPQRr && Opcode != AVR::STDWSPQRr)
continue;
assert(MI.getOperand(0).getReg() == AVR::SP &&
"Invalid register, should be SP!");
// Replace this instruction with a regular store. Use Y as the base
// pointer since it is guaranteed to contain a copy of SP.
unsigned STOpc =
(Opcode == AVR::STDWSPQRr) ? AVR::STDWPtrQRr : AVR::STDPtrQRr;
MI.setDesc(TII.get(STOpc));
MI.getOperand(0).setReg(FP);
}
}
MachineBasicBlock::iterator AVRFrameLowering::eliminateCallFramePseudoInstr(
MachineFunction &MF, MachineBasicBlock &MBB,
MachineBasicBlock::iterator MI) const {
const AVRSubtarget &STI = MF.getSubtarget<AVRSubtarget>();
const AVRInstrInfo &TII = *STI.getInstrInfo();
// There is nothing to insert when the call frame memory is allocated during
// function entry. Delete the call frame pseudo and replace all pseudo stores
// with real store instructions.
if (hasReservedCallFrame(MF)) {
fixStackStores(MBB, MI, TII, AVR::R29R28);
return MBB.erase(MI);
}
DebugLoc DL = MI->getDebugLoc();
unsigned int Opcode = MI->getOpcode();
int Amount = TII.getFrameSize(*MI);
// ADJCALLSTACKUP and ADJCALLSTACKDOWN are converted to adiw/subi
// instructions to read and write the stack pointer in I/O space.
if (Amount != 0) {
assert(getStackAlign() == Align(1) && "Unsupported stack alignment");
if (Opcode == TII.getCallFrameSetupOpcode()) {
// Update the stack pointer.
// In many cases this can be done far more efficiently by pushing the
// relevant values directly to the stack. However, doing that correctly
// (in the right order, possibly skipping some empty space for undef
// values, etc) is tricky and thus left to be optimized in the future.
BuildMI(MBB, MI, DL, TII.get(AVR::SPREAD), AVR::R31R30).addReg(AVR::SP);
MachineInstr *New =
BuildMI(MBB, MI, DL, TII.get(AVR::SUBIWRdK), AVR::R31R30)
.addReg(AVR::R31R30, RegState::Kill)
.addImm(Amount);
New->getOperand(3).setIsDead();
BuildMI(MBB, MI, DL, TII.get(AVR::SPWRITE), AVR::SP).addReg(AVR::R31R30);
// Make sure the remaining stack stores are converted to real store
// instructions.
fixStackStores(MBB, MI, TII, AVR::R31R30);
} else {
assert(Opcode == TII.getCallFrameDestroyOpcode());
// Note that small stack changes could be implemented more efficiently
// with a few pop instructions instead of the 8-9 instructions now
// required.
// Select the best opcode to adjust SP based on the offset size.
unsigned addOpcode;
if (isUInt<6>(Amount)) {
addOpcode = AVR::ADIWRdK;
} else {
addOpcode = AVR::SUBIWRdK;
Amount = -Amount;
}
// Build the instruction sequence.
BuildMI(MBB, MI, DL, TII.get(AVR::SPREAD), AVR::R31R30).addReg(AVR::SP);
MachineInstr *New = BuildMI(MBB, MI, DL, TII.get(addOpcode), AVR::R31R30)
.addReg(AVR::R31R30, RegState::Kill)
.addImm(Amount);
New->getOperand(3).setIsDead();
BuildMI(MBB, MI, DL, TII.get(AVR::SPWRITE), AVR::SP)
.addReg(AVR::R31R30, RegState::Kill);
}
}
return MBB.erase(MI);
}
void AVRFrameLowering::determineCalleeSaves(MachineFunction &MF,
BitVector &SavedRegs,
RegScavenger *RS) const {
TargetFrameLowering::determineCalleeSaves(MF, SavedRegs, RS);
// If we have a frame pointer, the Y register needs to be saved as well.
if (hasFP(MF)) {
SavedRegs.set(AVR::R29);
SavedRegs.set(AVR::R28);
}
}
/// The frame analyzer pass.
///
/// Scans the function for allocas and used arguments
/// that are passed through the stack.
struct AVRFrameAnalyzer : public MachineFunctionPass {
static char ID;
AVRFrameAnalyzer() : MachineFunctionPass(ID) {}
bool runOnMachineFunction(MachineFunction &MF) override {
const MachineFrameInfo &MFI = MF.getFrameInfo();
AVRMachineFunctionInfo *FuncInfo = MF.getInfo<AVRMachineFunctionInfo>();
// If there are no fixed frame indexes during this stage it means there
// are allocas present in the function.
if (MFI.getNumObjects() != MFI.getNumFixedObjects()) {
// Check for the type of allocas present in the function. We only care
// about fixed size allocas so do not give false positives if only
// variable sized allocas are present.
for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
// Variable sized objects have size 0.
if (MFI.getObjectSize(i)) {
FuncInfo->setHasAllocas(true);
break;
}
}
}
// If there are fixed frame indexes present, scan the function to see if
// they are really being used.
if (MFI.getNumFixedObjects() == 0) {
return false;
}
// Ok fixed frame indexes present, now scan the function to see if they
// are really being used, otherwise we can ignore them.
for (const MachineBasicBlock &BB : MF) {
for (const MachineInstr &MI : BB) {
int Opcode = MI.getOpcode();
if ((Opcode != AVR::LDDRdPtrQ) && (Opcode != AVR::LDDWRdPtrQ) &&
(Opcode != AVR::STDPtrQRr) && (Opcode != AVR::STDWPtrQRr)) {
continue;
}
for (const MachineOperand &MO : MI.operands()) {
if (!MO.isFI()) {
continue;
}
if (MFI.isFixedObjectIndex(MO.getIndex())) {
FuncInfo->setHasStackArgs(true);
return false;
}
}
}
}
return false;
}
StringRef getPassName() const override { return "AVR Frame Analyzer"; }
};
char AVRFrameAnalyzer::ID = 0;
/// Creates instance of the frame analyzer pass.
FunctionPass *createAVRFrameAnalyzerPass() { return new AVRFrameAnalyzer(); }
} // end of namespace llvm
diff --git a/contrib/llvm-project/llvm/lib/Target/PowerPC/PPCISelLowering.cpp b/contrib/llvm-project/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
index cbeae0ab03b8..de9c5712a877 100644
--- a/contrib/llvm-project/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
+++ b/contrib/llvm-project/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
@@ -1,17973 +1,17975 @@
//===-- PPCISelLowering.cpp - PPC DAG Lowering Implementation -------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements the PPCISelLowering class.
//
//===----------------------------------------------------------------------===//
#include "PPCISelLowering.h"
#include "MCTargetDesc/PPCPredicates.h"
#include "PPC.h"
#include "PPCCCState.h"
#include "PPCCallingConv.h"
#include "PPCFrameLowering.h"
#include "PPCInstrInfo.h"
#include "PPCMachineFunctionInfo.h"
#include "PPCPerfectShuffle.h"
#include "PPCRegisterInfo.h"
#include "PPCSubtarget.h"
#include "PPCTargetMachine.h"
#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/None.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/CodeGen/CallingConvLower.h"
#include "llvm/CodeGen/ISDOpcodes.h"
#include "llvm/CodeGen/MachineBasicBlock.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/MachineJumpTableInfo.h"
#include "llvm/CodeGen/MachineLoopInfo.h"
#include "llvm/CodeGen/MachineMemOperand.h"
#include "llvm/CodeGen/MachineModuleInfo.h"
#include "llvm/CodeGen/MachineOperand.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/RuntimeLibcalls.h"
#include "llvm/CodeGen/SelectionDAG.h"
#include "llvm/CodeGen/SelectionDAGNodes.h"
#include "llvm/CodeGen/TargetInstrInfo.h"
#include "llvm/CodeGen/TargetLowering.h"
#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
#include "llvm/CodeGen/TargetRegisterInfo.h"
#include "llvm/CodeGen/ValueTypes.h"
#include "llvm/IR/CallingConv.h"
#include "llvm/IR/Constant.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/DebugLoc.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/IntrinsicsPowerPC.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/Use.h"
#include "llvm/IR/Value.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCRegisterInfo.h"
#include "llvm/MC/MCSectionXCOFF.h"
#include "llvm/MC/MCSymbolXCOFF.h"
#include "llvm/Support/AtomicOrdering.h"
#include "llvm/Support/BranchProbability.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/CodeGen.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/KnownBits.h"
#include "llvm/Support/MachineValueType.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetOptions.h"
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <iterator>
#include <list>
#include <utility>
#include <vector>
using namespace llvm;
#define DEBUG_TYPE "ppc-lowering"
static cl::opt<bool> DisablePPCPreinc("disable-ppc-preinc",
cl::desc("disable preincrement load/store generation on PPC"), cl::Hidden);
static cl::opt<bool> DisableILPPref("disable-ppc-ilp-pref",
cl::desc("disable setting the node scheduling preference to ILP on PPC"), cl::Hidden);
static cl::opt<bool> DisablePPCUnaligned("disable-ppc-unaligned",
cl::desc("disable unaligned load/store generation on PPC"), cl::Hidden);
static cl::opt<bool> DisableSCO("disable-ppc-sco",
cl::desc("disable sibling call optimization on ppc"), cl::Hidden);
static cl::opt<bool> DisableInnermostLoopAlign32("disable-ppc-innermost-loop-align32",
cl::desc("don't always align innermost loop to 32 bytes on ppc"), cl::Hidden);
static cl::opt<bool> UseAbsoluteJumpTables("ppc-use-absolute-jumptables",
cl::desc("use absolute jump tables on ppc"), cl::Hidden);
static cl::opt<bool> EnableQuadwordAtomics(
"ppc-quadword-atomics",
cl::desc("enable quadword lock-free atomic operations"), cl::init(false),
cl::Hidden);
STATISTIC(NumTailCalls, "Number of tail calls");
STATISTIC(NumSiblingCalls, "Number of sibling calls");
STATISTIC(ShufflesHandledWithVPERM, "Number of shuffles lowered to a VPERM");
STATISTIC(NumDynamicAllocaProbed, "Number of dynamic stack allocation probed");
static bool isNByteElemShuffleMask(ShuffleVectorSDNode *, unsigned, int);
static SDValue widenVec(SelectionDAG &DAG, SDValue Vec, const SDLoc &dl);
static const char AIXSSPCanaryWordName[] = "__ssp_canary_word";
// FIXME: Remove this once the bug has been fixed!
extern cl::opt<bool> ANDIGlueBug;
PPCTargetLowering::PPCTargetLowering(const PPCTargetMachine &TM,
const PPCSubtarget &STI)
: TargetLowering(TM), Subtarget(STI) {
// Initialize map that relates the PPC addressing modes to the computed flags
// of a load/store instruction. The map is used to determine the optimal
// addressing mode when selecting load and stores.
initializeAddrModeMap();
// On PPC32/64, arguments smaller than 4/8 bytes are extended, so all
// arguments are at least 4/8 bytes aligned.
bool isPPC64 = Subtarget.isPPC64();
setMinStackArgumentAlignment(isPPC64 ? Align(8) : Align(4));
// Set up the register classes.
addRegisterClass(MVT::i32, &PPC::GPRCRegClass);
if (!useSoftFloat()) {
if (hasSPE()) {
addRegisterClass(MVT::f32, &PPC::GPRCRegClass);
// EFPU2 APU only supports f32
if (!Subtarget.hasEFPU2())
addRegisterClass(MVT::f64, &PPC::SPERCRegClass);
} else {
addRegisterClass(MVT::f32, &PPC::F4RCRegClass);
addRegisterClass(MVT::f64, &PPC::F8RCRegClass);
}
}
// Match BITREVERSE to customized fast code sequence in the td file.
setOperationAction(ISD::BITREVERSE, MVT::i32, Legal);
setOperationAction(ISD::BITREVERSE, MVT::i64, Legal);
// Sub-word ATOMIC_CMP_SWAP need to ensure that the input is zero-extended.
setOperationAction(ISD::ATOMIC_CMP_SWAP, MVT::i32, Custom);
// Custom lower inline assembly to check for special registers.
setOperationAction(ISD::INLINEASM, MVT::Other, Custom);
setOperationAction(ISD::INLINEASM_BR, MVT::Other, Custom);
// PowerPC has an i16 but no i8 (or i1) SEXTLOAD.
for (MVT VT : MVT::integer_valuetypes()) {
setLoadExtAction(ISD::SEXTLOAD, VT, MVT::i1, Promote);
setLoadExtAction(ISD::SEXTLOAD, VT, MVT::i8, Expand);
}
if (Subtarget.isISA3_0()) {
setLoadExtAction(ISD::EXTLOAD, MVT::f64, MVT::f16, Legal);
setLoadExtAction(ISD::EXTLOAD, MVT::f32, MVT::f16, Legal);
setTruncStoreAction(MVT::f64, MVT::f16, Legal);
setTruncStoreAction(MVT::f32, MVT::f16, Legal);
} else {
// No extending loads from f16 or HW conversions back and forth.
setLoadExtAction(ISD::EXTLOAD, MVT::f64, MVT::f16, Expand);
setOperationAction(ISD::FP16_TO_FP, MVT::f64, Expand);
setOperationAction(ISD::FP_TO_FP16, MVT::f64, Expand);
setLoadExtAction(ISD::EXTLOAD, MVT::f32, MVT::f16, Expand);
setOperationAction(ISD::FP16_TO_FP, MVT::f32, Expand);
setOperationAction(ISD::FP_TO_FP16, MVT::f32, Expand);
setTruncStoreAction(MVT::f64, MVT::f16, Expand);
setTruncStoreAction(MVT::f32, MVT::f16, Expand);
}
setTruncStoreAction(MVT::f64, MVT::f32, Expand);
// PowerPC has pre-inc load and store's.
setIndexedLoadAction(ISD::PRE_INC, MVT::i1, Legal);
setIndexedLoadAction(ISD::PRE_INC, MVT::i8, Legal);
setIndexedLoadAction(ISD::PRE_INC, MVT::i16, Legal);
setIndexedLoadAction(ISD::PRE_INC, MVT::i32, Legal);
setIndexedLoadAction(ISD::PRE_INC, MVT::i64, Legal);
setIndexedStoreAction(ISD::PRE_INC, MVT::i1, Legal);
setIndexedStoreAction(ISD::PRE_INC, MVT::i8, Legal);
setIndexedStoreAction(ISD::PRE_INC, MVT::i16, Legal);
setIndexedStoreAction(ISD::PRE_INC, MVT::i32, Legal);
setIndexedStoreAction(ISD::PRE_INC, MVT::i64, Legal);
if (!Subtarget.hasSPE()) {
setIndexedLoadAction(ISD::PRE_INC, MVT::f32, Legal);
setIndexedLoadAction(ISD::PRE_INC, MVT::f64, Legal);
setIndexedStoreAction(ISD::PRE_INC, MVT::f32, Legal);
setIndexedStoreAction(ISD::PRE_INC, MVT::f64, Legal);
}
// PowerPC uses ADDC/ADDE/SUBC/SUBE to propagate carry.
const MVT ScalarIntVTs[] = { MVT::i32, MVT::i64 };
for (MVT VT : ScalarIntVTs) {
setOperationAction(ISD::ADDC, VT, Legal);
setOperationAction(ISD::ADDE, VT, Legal);
setOperationAction(ISD::SUBC, VT, Legal);
setOperationAction(ISD::SUBE, VT, Legal);
}
if (Subtarget.useCRBits()) {
setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Expand);
if (isPPC64 || Subtarget.hasFPCVT()) {
setOperationAction(ISD::STRICT_SINT_TO_FP, MVT::i1, Promote);
AddPromotedToType(ISD::STRICT_SINT_TO_FP, MVT::i1,
isPPC64 ? MVT::i64 : MVT::i32);
setOperationAction(ISD::STRICT_UINT_TO_FP, MVT::i1, Promote);
AddPromotedToType(ISD::STRICT_UINT_TO_FP, MVT::i1,
isPPC64 ? MVT::i64 : MVT::i32);
setOperationAction(ISD::SINT_TO_FP, MVT::i1, Promote);
AddPromotedToType (ISD::SINT_TO_FP, MVT::i1,
isPPC64 ? MVT::i64 : MVT::i32);
setOperationAction(ISD::UINT_TO_FP, MVT::i1, Promote);
AddPromotedToType(ISD::UINT_TO_FP, MVT::i1,
isPPC64 ? MVT::i64 : MVT::i32);
setOperationAction(ISD::STRICT_FP_TO_SINT, MVT::i1, Promote);
AddPromotedToType(ISD::STRICT_FP_TO_SINT, MVT::i1,
isPPC64 ? MVT::i64 : MVT::i32);
setOperationAction(ISD::STRICT_FP_TO_UINT, MVT::i1, Promote);
AddPromotedToType(ISD::STRICT_FP_TO_UINT, MVT::i1,
isPPC64 ? MVT::i64 : MVT::i32);
setOperationAction(ISD::FP_TO_SINT, MVT::i1, Promote);
AddPromotedToType(ISD::FP_TO_SINT, MVT::i1,
isPPC64 ? MVT::i64 : MVT::i32);
setOperationAction(ISD::FP_TO_UINT, MVT::i1, Promote);
AddPromotedToType(ISD::FP_TO_UINT, MVT::i1,
isPPC64 ? MVT::i64 : MVT::i32);
} else {
setOperationAction(ISD::STRICT_SINT_TO_FP, MVT::i1, Custom);
setOperationAction(ISD::STRICT_UINT_TO_FP, MVT::i1, Custom);
setOperationAction(ISD::SINT_TO_FP, MVT::i1, Custom);
setOperationAction(ISD::UINT_TO_FP, MVT::i1, Custom);
}
// PowerPC does not support direct load/store of condition registers.
setOperationAction(ISD::LOAD, MVT::i1, Custom);
setOperationAction(ISD::STORE, MVT::i1, Custom);
// FIXME: Remove this once the ANDI glue bug is fixed:
if (ANDIGlueBug)
setOperationAction(ISD::TRUNCATE, MVT::i1, Custom);
for (MVT VT : MVT::integer_valuetypes()) {
setLoadExtAction(ISD::SEXTLOAD, VT, MVT::i1, Promote);
setLoadExtAction(ISD::ZEXTLOAD, VT, MVT::i1, Promote);
setTruncStoreAction(VT, MVT::i1, Expand);
}
addRegisterClass(MVT::i1, &PPC::CRBITRCRegClass);
}
// Expand ppcf128 to i32 by hand for the benefit of llvm-gcc bootstrap on
// PPC (the libcall is not available).
setOperationAction(ISD::FP_TO_SINT, MVT::ppcf128, Custom);
setOperationAction(ISD::FP_TO_UINT, MVT::ppcf128, Custom);
setOperationAction(ISD::STRICT_FP_TO_SINT, MVT::ppcf128, Custom);
setOperationAction(ISD::STRICT_FP_TO_UINT, MVT::ppcf128, Custom);
// We do not currently implement these libm ops for PowerPC.
setOperationAction(ISD::FFLOOR, MVT::ppcf128, Expand);
setOperationAction(ISD::FCEIL, MVT::ppcf128, Expand);
setOperationAction(ISD::FTRUNC, MVT::ppcf128, Expand);
setOperationAction(ISD::FRINT, MVT::ppcf128, Expand);
setOperationAction(ISD::FNEARBYINT, MVT::ppcf128, Expand);
setOperationAction(ISD::FREM, MVT::ppcf128, Expand);
// PowerPC has no SREM/UREM instructions unless we are on P9
// On P9 we may use a hardware instruction to compute the remainder.
// When the result of both the remainder and the division is required it is
// more efficient to compute the remainder from the result of the division
// rather than use the remainder instruction. The instructions are legalized
// directly because the DivRemPairsPass performs the transformation at the IR
// level.
if (Subtarget.isISA3_0()) {
setOperationAction(ISD::SREM, MVT::i32, Legal);
setOperationAction(ISD::UREM, MVT::i32, Legal);
setOperationAction(ISD::SREM, MVT::i64, Legal);
setOperationAction(ISD::UREM, MVT::i64, Legal);
} else {
setOperationAction(ISD::SREM, MVT::i32, Expand);
setOperationAction(ISD::UREM, MVT::i32, Expand);
setOperationAction(ISD::SREM, MVT::i64, Expand);
setOperationAction(ISD::UREM, MVT::i64, Expand);
}
// Don't use SMUL_LOHI/UMUL_LOHI or SDIVREM/UDIVREM to lower SREM/UREM.
setOperationAction(ISD::UMUL_LOHI, MVT::i32, Expand);
setOperationAction(ISD::SMUL_LOHI, MVT::i32, Expand);
setOperationAction(ISD::UMUL_LOHI, MVT::i64, Expand);
setOperationAction(ISD::SMUL_LOHI, MVT::i64, Expand);
setOperationAction(ISD::UDIVREM, MVT::i32, Expand);
setOperationAction(ISD::SDIVREM, MVT::i32, Expand);
setOperationAction(ISD::UDIVREM, MVT::i64, Expand);
setOperationAction(ISD::SDIVREM, MVT::i64, Expand);
// Handle constrained floating-point operations of scalar.
// TODO: Handle SPE specific operation.
setOperationAction(ISD::STRICT_FADD, MVT::f32, Legal);
setOperationAction(ISD::STRICT_FSUB, MVT::f32, Legal);
setOperationAction(ISD::STRICT_FMUL, MVT::f32, Legal);
setOperationAction(ISD::STRICT_FDIV, MVT::f32, Legal);
setOperationAction(ISD::STRICT_FP_ROUND, MVT::f32, Legal);
setOperationAction(ISD::STRICT_FADD, MVT::f64, Legal);
setOperationAction(ISD::STRICT_FSUB, MVT::f64, Legal);
setOperationAction(ISD::STRICT_FMUL, MVT::f64, Legal);
setOperationAction(ISD::STRICT_FDIV, MVT::f64, Legal);
if (!Subtarget.hasSPE()) {
setOperationAction(ISD::STRICT_FMA, MVT::f32, Legal);
setOperationAction(ISD::STRICT_FMA, MVT::f64, Legal);
}
if (Subtarget.hasVSX()) {
setOperationAction(ISD::STRICT_FRINT, MVT::f32, Legal);
setOperationAction(ISD::STRICT_FRINT, MVT::f64, Legal);
}
if (Subtarget.hasFSQRT()) {
setOperationAction(ISD::STRICT_FSQRT, MVT::f32, Legal);
setOperationAction(ISD::STRICT_FSQRT, MVT::f64, Legal);
}
if (Subtarget.hasFPRND()) {
setOperationAction(ISD::STRICT_FFLOOR, MVT::f32, Legal);
setOperationAction(ISD::STRICT_FCEIL, MVT::f32, Legal);
setOperationAction(ISD::STRICT_FTRUNC, MVT::f32, Legal);
setOperationAction(ISD::STRICT_FROUND, MVT::f32, Legal);
setOperationAction(ISD::STRICT_FFLOOR, MVT::f64, Legal);
setOperationAction(ISD::STRICT_FCEIL, MVT::f64, Legal);
setOperationAction(ISD::STRICT_FTRUNC, MVT::f64, Legal);
setOperationAction(ISD::STRICT_FROUND, MVT::f64, Legal);
}
// We don't support sin/cos/sqrt/fmod/pow
setOperationAction(ISD::FSIN , MVT::f64, Expand);
setOperationAction(ISD::FCOS , MVT::f64, Expand);
setOperationAction(ISD::FSINCOS, MVT::f64, Expand);
setOperationAction(ISD::FREM , MVT::f64, Expand);
setOperationAction(ISD::FPOW , MVT::f64, Expand);
setOperationAction(ISD::FSIN , MVT::f32, Expand);
setOperationAction(ISD::FCOS , MVT::f32, Expand);
setOperationAction(ISD::FSINCOS, MVT::f32, Expand);
setOperationAction(ISD::FREM , MVT::f32, Expand);
setOperationAction(ISD::FPOW , MVT::f32, Expand);
if (Subtarget.hasSPE()) {
setOperationAction(ISD::FMA , MVT::f64, Expand);
setOperationAction(ISD::FMA , MVT::f32, Expand);
} else {
setOperationAction(ISD::FMA , MVT::f64, Legal);
setOperationAction(ISD::FMA , MVT::f32, Legal);
}
if (Subtarget.hasSPE())
setLoadExtAction(ISD::EXTLOAD, MVT::f64, MVT::f32, Expand);
setOperationAction(ISD::FLT_ROUNDS_, MVT::i32, Custom);
// If we're enabling GP optimizations, use hardware square root
if (!Subtarget.hasFSQRT() &&
!(TM.Options.UnsafeFPMath && Subtarget.hasFRSQRTE() &&
Subtarget.hasFRE()))
setOperationAction(ISD::FSQRT, MVT::f64, Expand);
if (!Subtarget.hasFSQRT() &&
!(TM.Options.UnsafeFPMath && Subtarget.hasFRSQRTES() &&
Subtarget.hasFRES()))
setOperationAction(ISD::FSQRT, MVT::f32, Expand);
if (Subtarget.hasFCPSGN()) {
setOperationAction(ISD::FCOPYSIGN, MVT::f64, Legal);
setOperationAction(ISD::FCOPYSIGN, MVT::f32, Legal);
} else {
setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
setOperationAction(ISD::FCOPYSIGN, MVT::f32, Expand);
}
if (Subtarget.hasFPRND()) {
setOperationAction(ISD::FFLOOR, MVT::f64, Legal);
setOperationAction(ISD::FCEIL, MVT::f64, Legal);
setOperationAction(ISD::FTRUNC, MVT::f64, Legal);
setOperationAction(ISD::FROUND, MVT::f64, Legal);
setOperationAction(ISD::FFLOOR, MVT::f32, Legal);
setOperationAction(ISD::FCEIL, MVT::f32, Legal);
setOperationAction(ISD::FTRUNC, MVT::f32, Legal);
setOperationAction(ISD::FROUND, MVT::f32, Legal);
}
// PowerPC does not have BSWAP, but we can use vector BSWAP instruction xxbrd
// to speed up scalar BSWAP64.
// CTPOP or CTTZ were introduced in P8/P9 respectively
setOperationAction(ISD::BSWAP, MVT::i32 , Expand);
if (Subtarget.hasP9Vector() && Subtarget.isPPC64())
setOperationAction(ISD::BSWAP, MVT::i64 , Custom);
else
setOperationAction(ISD::BSWAP, MVT::i64 , Expand);
if (Subtarget.isISA3_0()) {
setOperationAction(ISD::CTTZ , MVT::i32 , Legal);
setOperationAction(ISD::CTTZ , MVT::i64 , Legal);
} else {
setOperationAction(ISD::CTTZ , MVT::i32 , Expand);
setOperationAction(ISD::CTTZ , MVT::i64 , Expand);
}
if (Subtarget.hasPOPCNTD() == PPCSubtarget::POPCNTD_Fast) {
setOperationAction(ISD::CTPOP, MVT::i32 , Legal);
setOperationAction(ISD::CTPOP, MVT::i64 , Legal);
} else {
setOperationAction(ISD::CTPOP, MVT::i32 , Expand);
setOperationAction(ISD::CTPOP, MVT::i64 , Expand);
}
// PowerPC does not have ROTR
setOperationAction(ISD::ROTR, MVT::i32 , Expand);
setOperationAction(ISD::ROTR, MVT::i64 , Expand);
if (!Subtarget.useCRBits()) {
// PowerPC does not have Select
setOperationAction(ISD::SELECT, MVT::i32, Expand);
setOperationAction(ISD::SELECT, MVT::i64, Expand);
setOperationAction(ISD::SELECT, MVT::f32, Expand);
setOperationAction(ISD::SELECT, MVT::f64, Expand);
}
// PowerPC wants to turn select_cc of FP into fsel when possible.
setOperationAction(ISD::SELECT_CC, MVT::f32, Custom);
setOperationAction(ISD::SELECT_CC, MVT::f64, Custom);
// PowerPC wants to optimize integer setcc a bit
if (!Subtarget.useCRBits())
setOperationAction(ISD::SETCC, MVT::i32, Custom);
if (Subtarget.hasFPU()) {
setOperationAction(ISD::STRICT_FSETCC, MVT::f32, Legal);
setOperationAction(ISD::STRICT_FSETCC, MVT::f64, Legal);
setOperationAction(ISD::STRICT_FSETCC, MVT::f128, Legal);
setOperationAction(ISD::STRICT_FSETCCS, MVT::f32, Legal);
setOperationAction(ISD::STRICT_FSETCCS, MVT::f64, Legal);
setOperationAction(ISD::STRICT_FSETCCS, MVT::f128, Legal);
}
// PowerPC does not have BRCOND which requires SetCC
if (!Subtarget.useCRBits())
setOperationAction(ISD::BRCOND, MVT::Other, Expand);
setOperationAction(ISD::BR_JT, MVT::Other, Expand);
if (Subtarget.hasSPE()) {
// SPE has built-in conversions
setOperationAction(ISD::STRICT_FP_TO_SINT, MVT::i32, Legal);
setOperationAction(ISD::STRICT_SINT_TO_FP, MVT::i32, Legal);
setOperationAction(ISD::STRICT_UINT_TO_FP, MVT::i32, Legal);
setOperationAction(ISD::FP_TO_SINT, MVT::i32, Legal);
setOperationAction(ISD::SINT_TO_FP, MVT::i32, Legal);
setOperationAction(ISD::UINT_TO_FP, MVT::i32, Legal);
// SPE supports signaling compare of f32/f64.
setOperationAction(ISD::STRICT_FSETCCS, MVT::f32, Legal);
setOperationAction(ISD::STRICT_FSETCCS, MVT::f64, Legal);
} else {
// PowerPC turns FP_TO_SINT into FCTIWZ and some load/stores.
setOperationAction(ISD::STRICT_FP_TO_SINT, MVT::i32, Custom);
setOperationAction(ISD::FP_TO_SINT, MVT::i32, Custom);
// PowerPC does not have [U|S]INT_TO_FP
setOperationAction(ISD::STRICT_SINT_TO_FP, MVT::i32, Expand);
setOperationAction(ISD::STRICT_UINT_TO_FP, MVT::i32, Expand);
setOperationAction(ISD::SINT_TO_FP, MVT::i32, Expand);
setOperationAction(ISD::UINT_TO_FP, MVT::i32, Expand);
}
if (Subtarget.hasDirectMove() && isPPC64) {
setOperationAction(ISD::BITCAST, MVT::f32, Legal);
setOperationAction(ISD::BITCAST, MVT::i32, Legal);
setOperationAction(ISD::BITCAST, MVT::i64, Legal);
setOperationAction(ISD::BITCAST, MVT::f64, Legal);
if (TM.Options.UnsafeFPMath) {
setOperationAction(ISD::LRINT, MVT::f64, Legal);
setOperationAction(ISD::LRINT, MVT::f32, Legal);
setOperationAction(ISD::LLRINT, MVT::f64, Legal);
setOperationAction(ISD::LLRINT, MVT::f32, Legal);
setOperationAction(ISD::LROUND, MVT::f64, Legal);
setOperationAction(ISD::LROUND, MVT::f32, Legal);
setOperationAction(ISD::LLROUND, MVT::f64, Legal);
setOperationAction(ISD::LLROUND, MVT::f32, Legal);
}
} else {
setOperationAction(ISD::BITCAST, MVT::f32, Expand);
setOperationAction(ISD::BITCAST, MVT::i32, Expand);
setOperationAction(ISD::BITCAST, MVT::i64, Expand);
setOperationAction(ISD::BITCAST, MVT::f64, Expand);
}
// We cannot sextinreg(i1). Expand to shifts.
setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Expand);
// NOTE: EH_SJLJ_SETJMP/_LONGJMP supported here is NOT intended to support
// SjLj exception handling but a light-weight setjmp/longjmp replacement to
// support continuation, user-level threading, and etc.. As a result, no
// other SjLj exception interfaces are implemented and please don't build
// your own exception handling based on them.
// LLVM/Clang supports zero-cost DWARF exception handling.
setOperationAction(ISD::EH_SJLJ_SETJMP, MVT::i32, Custom);
setOperationAction(ISD::EH_SJLJ_LONGJMP, MVT::Other, Custom);
// We want to legalize GlobalAddress and ConstantPool nodes into the
// appropriate instructions to materialize the address.
setOperationAction(ISD::GlobalAddress, MVT::i32, Custom);
setOperationAction(ISD::GlobalTLSAddress, MVT::i32, Custom);
setOperationAction(ISD::BlockAddress, MVT::i32, Custom);
setOperationAction(ISD::ConstantPool, MVT::i32, Custom);
setOperationAction(ISD::JumpTable, MVT::i32, Custom);
setOperationAction(ISD::GlobalAddress, MVT::i64, Custom);
setOperationAction(ISD::GlobalTLSAddress, MVT::i64, Custom);
setOperationAction(ISD::BlockAddress, MVT::i64, Custom);
setOperationAction(ISD::ConstantPool, MVT::i64, Custom);
setOperationAction(ISD::JumpTable, MVT::i64, Custom);
// TRAP is legal.
setOperationAction(ISD::TRAP, MVT::Other, Legal);
// TRAMPOLINE is custom lowered.
setOperationAction(ISD::INIT_TRAMPOLINE, MVT::Other, Custom);
setOperationAction(ISD::ADJUST_TRAMPOLINE, MVT::Other, Custom);
// VASTART needs to be custom lowered to use the VarArgsFrameIndex
setOperationAction(ISD::VASTART , MVT::Other, Custom);
if (Subtarget.is64BitELFABI()) {
// VAARG always uses double-word chunks, so promote anything smaller.
setOperationAction(ISD::VAARG, MVT::i1, Promote);
AddPromotedToType(ISD::VAARG, MVT::i1, MVT::i64);
setOperationAction(ISD::VAARG, MVT::i8, Promote);
AddPromotedToType(ISD::VAARG, MVT::i8, MVT::i64);
setOperationAction(ISD::VAARG, MVT::i16, Promote);
AddPromotedToType(ISD::VAARG, MVT::i16, MVT::i64);
setOperationAction(ISD::VAARG, MVT::i32, Promote);
AddPromotedToType(ISD::VAARG, MVT::i32, MVT::i64);
setOperationAction(ISD::VAARG, MVT::Other, Expand);
} else if (Subtarget.is32BitELFABI()) {
// VAARG is custom lowered with the 32-bit SVR4 ABI.
setOperationAction(ISD::VAARG, MVT::Other, Custom);
setOperationAction(ISD::VAARG, MVT::i64, Custom);
} else
setOperationAction(ISD::VAARG, MVT::Other, Expand);
// VACOPY is custom lowered with the 32-bit SVR4 ABI.
if (Subtarget.is32BitELFABI())
setOperationAction(ISD::VACOPY , MVT::Other, Custom);
else
setOperationAction(ISD::VACOPY , MVT::Other, Expand);
// Use the default implementation.
setOperationAction(ISD::VAEND , MVT::Other, Expand);
setOperationAction(ISD::STACKSAVE , MVT::Other, Expand);
setOperationAction(ISD::STACKRESTORE , MVT::Other, Custom);
setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i32 , Custom);
setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i64 , Custom);
setOperationAction(ISD::GET_DYNAMIC_AREA_OFFSET, MVT::i32, Custom);
setOperationAction(ISD::GET_DYNAMIC_AREA_OFFSET, MVT::i64, Custom);
setOperationAction(ISD::EH_DWARF_CFA, MVT::i32, Custom);
setOperationAction(ISD::EH_DWARF_CFA, MVT::i64, Custom);
// We want to custom lower some of our intrinsics.
setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::f64, Custom);
setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::ppcf128, Custom);
// To handle counter-based loop conditions.
setOperationAction(ISD::INTRINSIC_W_CHAIN, MVT::i1, Custom);
setOperationAction(ISD::INTRINSIC_VOID, MVT::i8, Custom);
setOperationAction(ISD::INTRINSIC_VOID, MVT::i16, Custom);
setOperationAction(ISD::INTRINSIC_VOID, MVT::i32, Custom);
setOperationAction(ISD::INTRINSIC_VOID, MVT::Other, Custom);
// Comparisons that require checking two conditions.
if (Subtarget.hasSPE()) {
setCondCodeAction(ISD::SETO, MVT::f32, Expand);
setCondCodeAction(ISD::SETO, MVT::f64, Expand);
setCondCodeAction(ISD::SETUO, MVT::f32, Expand);
setCondCodeAction(ISD::SETUO, MVT::f64, Expand);
}
setCondCodeAction(ISD::SETULT, MVT::f32, Expand);
setCondCodeAction(ISD::SETULT, MVT::f64, Expand);
setCondCodeAction(ISD::SETUGT, MVT::f32, Expand);
setCondCodeAction(ISD::SETUGT, MVT::f64, Expand);
setCondCodeAction(ISD::SETUEQ, MVT::f32, Expand);
setCondCodeAction(ISD::SETUEQ, MVT::f64, Expand);
setCondCodeAction(ISD::SETOGE, MVT::f32, Expand);
setCondCodeAction(ISD::SETOGE, MVT::f64, Expand);
setCondCodeAction(ISD::SETOLE, MVT::f32, Expand);
setCondCodeAction(ISD::SETOLE, MVT::f64, Expand);
setCondCodeAction(ISD::SETONE, MVT::f32, Expand);
setCondCodeAction(ISD::SETONE, MVT::f64, Expand);
setOperationAction(ISD::STRICT_FP_EXTEND, MVT::f32, Legal);
setOperationAction(ISD::STRICT_FP_EXTEND, MVT::f64, Legal);
if (Subtarget.has64BitSupport()) {
// They also have instructions for converting between i64 and fp.
setOperationAction(ISD::STRICT_FP_TO_SINT, MVT::i64, Custom);
setOperationAction(ISD::STRICT_FP_TO_UINT, MVT::i64, Expand);
setOperationAction(ISD::STRICT_SINT_TO_FP, MVT::i64, Custom);
setOperationAction(ISD::STRICT_UINT_TO_FP, MVT::i64, Expand);
setOperationAction(ISD::FP_TO_SINT, MVT::i64, Custom);
setOperationAction(ISD::FP_TO_UINT, MVT::i64, Expand);
setOperationAction(ISD::SINT_TO_FP, MVT::i64, Custom);
setOperationAction(ISD::UINT_TO_FP, MVT::i64, Expand);
// This is just the low 32 bits of a (signed) fp->i64 conversion.
// We cannot do this with Promote because i64 is not a legal type.
setOperationAction(ISD::STRICT_FP_TO_UINT, MVT::i32, Custom);
setOperationAction(ISD::FP_TO_UINT, MVT::i32, Custom);
if (Subtarget.hasLFIWAX() || Subtarget.isPPC64()) {
setOperationAction(ISD::SINT_TO_FP, MVT::i32, Custom);
setOperationAction(ISD::STRICT_SINT_TO_FP, MVT::i32, Custom);
}
} else {
// PowerPC does not have FP_TO_UINT on 32-bit implementations.
if (Subtarget.hasSPE()) {
setOperationAction(ISD::STRICT_FP_TO_UINT, MVT::i32, Legal);
setOperationAction(ISD::FP_TO_UINT, MVT::i32, Legal);
} else {
setOperationAction(ISD::STRICT_FP_TO_UINT, MVT::i32, Expand);
setOperationAction(ISD::FP_TO_UINT, MVT::i32, Expand);
}
}
// With the instructions enabled under FPCVT, we can do everything.
if (Subtarget.hasFPCVT()) {
if (Subtarget.has64BitSupport()) {
setOperationAction(ISD::STRICT_FP_TO_SINT, MVT::i64, Custom);
setOperationAction(ISD::STRICT_FP_TO_UINT, MVT::i64, Custom);
setOperationAction(ISD::STRICT_SINT_TO_FP, MVT::i64, Custom);
setOperationAction(ISD::STRICT_UINT_TO_FP, MVT::i64, Custom);
setOperationAction(ISD::FP_TO_SINT, MVT::i64, Custom);
setOperationAction(ISD::FP_TO_UINT, MVT::i64, Custom);
setOperationAction(ISD::SINT_TO_FP, MVT::i64, Custom);
setOperationAction(ISD::UINT_TO_FP, MVT::i64, Custom);
}
setOperationAction(ISD::STRICT_FP_TO_SINT, MVT::i32, Custom);
setOperationAction(ISD::STRICT_FP_TO_UINT, MVT::i32, Custom);
setOperationAction(ISD::STRICT_SINT_TO_FP, MVT::i32, Custom);
setOperationAction(ISD::STRICT_UINT_TO_FP, MVT::i32, Custom);
setOperationAction(ISD::FP_TO_SINT, MVT::i32, Custom);
setOperationAction(ISD::FP_TO_UINT, MVT::i32, Custom);
setOperationAction(ISD::SINT_TO_FP, MVT::i32, Custom);
setOperationAction(ISD::UINT_TO_FP, MVT::i32, Custom);
}
if (Subtarget.use64BitRegs()) {
// 64-bit PowerPC implementations can support i64 types directly
addRegisterClass(MVT::i64, &PPC::G8RCRegClass);
// BUILD_PAIR can't be handled natively, and should be expanded to shl/or
setOperationAction(ISD::BUILD_PAIR, MVT::i64, Expand);
// 64-bit PowerPC wants to expand i128 shifts itself.
setOperationAction(ISD::SHL_PARTS, MVT::i64, Custom);
setOperationAction(ISD::SRA_PARTS, MVT::i64, Custom);
setOperationAction(ISD::SRL_PARTS, MVT::i64, Custom);
} else {
// 32-bit PowerPC wants to expand i64 shifts itself.
setOperationAction(ISD::SHL_PARTS, MVT::i32, Custom);
setOperationAction(ISD::SRA_PARTS, MVT::i32, Custom);
setOperationAction(ISD::SRL_PARTS, MVT::i32, Custom);
}
// PowerPC has better expansions for funnel shifts than the generic
// TargetLowering::expandFunnelShift.
if (Subtarget.has64BitSupport()) {
setOperationAction(ISD::FSHL, MVT::i64, Custom);
setOperationAction(ISD::FSHR, MVT::i64, Custom);
}
setOperationAction(ISD::FSHL, MVT::i32, Custom);
setOperationAction(ISD::FSHR, MVT::i32, Custom);
if (Subtarget.hasVSX()) {
setOperationAction(ISD::FMAXNUM_IEEE, MVT::f64, Legal);
setOperationAction(ISD::FMAXNUM_IEEE, MVT::f32, Legal);
setOperationAction(ISD::FMINNUM_IEEE, MVT::f64, Legal);
setOperationAction(ISD::FMINNUM_IEEE, MVT::f32, Legal);
}
if (Subtarget.hasAltivec()) {
for (MVT VT : { MVT::v16i8, MVT::v8i16, MVT::v4i32 }) {
setOperationAction(ISD::SADDSAT, VT, Legal);
setOperationAction(ISD::SSUBSAT, VT, Legal);
setOperationAction(ISD::UADDSAT, VT, Legal);
setOperationAction(ISD::USUBSAT, VT, Legal);
}
// First set operation action for all vector types to expand. Then we
// will selectively turn on ones that can be effectively codegen'd.
for (MVT VT : MVT::fixedlen_vector_valuetypes()) {
// add/sub are legal for all supported vector VT's.
setOperationAction(ISD::ADD, VT, Legal);
setOperationAction(ISD::SUB, VT, Legal);
// For v2i64, these are only valid with P8Vector. This is corrected after
// the loop.
if (VT.getSizeInBits() <= 128 && VT.getScalarSizeInBits() <= 64) {
setOperationAction(ISD::SMAX, VT, Legal);
setOperationAction(ISD::SMIN, VT, Legal);
setOperationAction(ISD::UMAX, VT, Legal);
setOperationAction(ISD::UMIN, VT, Legal);
}
else {
setOperationAction(ISD::SMAX, VT, Expand);
setOperationAction(ISD::SMIN, VT, Expand);
setOperationAction(ISD::UMAX, VT, Expand);
setOperationAction(ISD::UMIN, VT, Expand);
}
if (Subtarget.hasVSX()) {
setOperationAction(ISD::FMAXNUM, VT, Legal);
setOperationAction(ISD::FMINNUM, VT, Legal);
}
// Vector instructions introduced in P8
if (Subtarget.hasP8Altivec() && (VT.SimpleTy != MVT::v1i128)) {
setOperationAction(ISD::CTPOP, VT, Legal);
setOperationAction(ISD::CTLZ, VT, Legal);
}
else {
setOperationAction(ISD::CTPOP, VT, Expand);
setOperationAction(ISD::CTLZ, VT, Expand);
}
// Vector instructions introduced in P9
if (Subtarget.hasP9Altivec() && (VT.SimpleTy != MVT::v1i128))
setOperationAction(ISD::CTTZ, VT, Legal);
else
setOperationAction(ISD::CTTZ, VT, Expand);
// We promote all shuffles to v16i8.
setOperationAction(ISD::VECTOR_SHUFFLE, VT, Promote);
AddPromotedToType (ISD::VECTOR_SHUFFLE, VT, MVT::v16i8);
// We promote all non-typed operations to v4i32.
setOperationAction(ISD::AND , VT, Promote);
AddPromotedToType (ISD::AND , VT, MVT::v4i32);
setOperationAction(ISD::OR , VT, Promote);
AddPromotedToType (ISD::OR , VT, MVT::v4i32);
setOperationAction(ISD::XOR , VT, Promote);
AddPromotedToType (ISD::XOR , VT, MVT::v4i32);
setOperationAction(ISD::LOAD , VT, Promote);
AddPromotedToType (ISD::LOAD , VT, MVT::v4i32);
setOperationAction(ISD::SELECT, VT, Promote);
AddPromotedToType (ISD::SELECT, VT, MVT::v4i32);
setOperationAction(ISD::VSELECT, VT, Legal);
setOperationAction(ISD::SELECT_CC, VT, Promote);
AddPromotedToType (ISD::SELECT_CC, VT, MVT::v4i32);
setOperationAction(ISD::STORE, VT, Promote);
AddPromotedToType (ISD::STORE, VT, MVT::v4i32);
// No other operations are legal.
setOperationAction(ISD::MUL , VT, Expand);
setOperationAction(ISD::SDIV, VT, Expand);
setOperationAction(ISD::SREM, VT, Expand);
setOperationAction(ISD::UDIV, VT, Expand);
setOperationAction(ISD::UREM, VT, Expand);
setOperationAction(ISD::FDIV, VT, Expand);
setOperationAction(ISD::FREM, VT, Expand);
setOperationAction(ISD::FNEG, VT, Expand);
setOperationAction(ISD::FSQRT, VT, Expand);
setOperationAction(ISD::FLOG, VT, Expand);
setOperationAction(ISD::FLOG10, VT, Expand);
setOperationAction(ISD::FLOG2, VT, Expand);
setOperationAction(ISD::FEXP, VT, Expand);
setOperationAction(ISD::FEXP2, VT, Expand);
setOperationAction(ISD::FSIN, VT, Expand);
setOperationAction(ISD::FCOS, VT, Expand);
setOperationAction(ISD::FABS, VT, Expand);
setOperationAction(ISD::FFLOOR, VT, Expand);
setOperationAction(ISD::FCEIL, VT, Expand);
setOperationAction(ISD::FTRUNC, VT, Expand);
setOperationAction(ISD::FRINT, VT, Expand);
setOperationAction(ISD::FNEARBYINT, VT, Expand);
setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT, Expand);
setOperationAction(ISD::INSERT_VECTOR_ELT, VT, Expand);
setOperationAction(ISD::BUILD_VECTOR, VT, Expand);
setOperationAction(ISD::MULHU, VT, Expand);
setOperationAction(ISD::MULHS, VT, Expand);
setOperationAction(ISD::UMUL_LOHI, VT, Expand);
setOperationAction(ISD::SMUL_LOHI, VT, Expand);
setOperationAction(ISD::UDIVREM, VT, Expand);
setOperationAction(ISD::SDIVREM, VT, Expand);
setOperationAction(ISD::SCALAR_TO_VECTOR, VT, Expand);
setOperationAction(ISD::FPOW, VT, Expand);
setOperationAction(ISD::BSWAP, VT, Expand);
setOperationAction(ISD::SIGN_EXTEND_INREG, VT, Expand);
setOperationAction(ISD::ROTL, VT, Expand);
setOperationAction(ISD::ROTR, VT, Expand);
for (MVT InnerVT : MVT::fixedlen_vector_valuetypes()) {
setTruncStoreAction(VT, InnerVT, Expand);
setLoadExtAction(ISD::SEXTLOAD, VT, InnerVT, Expand);
setLoadExtAction(ISD::ZEXTLOAD, VT, InnerVT, Expand);
setLoadExtAction(ISD::EXTLOAD, VT, InnerVT, Expand);
}
}
setOperationAction(ISD::SELECT_CC, MVT::v4i32, Expand);
if (!Subtarget.hasP8Vector()) {
setOperationAction(ISD::SMAX, MVT::v2i64, Expand);
setOperationAction(ISD::SMIN, MVT::v2i64, Expand);
setOperationAction(ISD::UMAX, MVT::v2i64, Expand);
setOperationAction(ISD::UMIN, MVT::v2i64, Expand);
}
// We can custom expand all VECTOR_SHUFFLEs to VPERM, others we can handle
// with merges, splats, etc.
setOperationAction(ISD::VECTOR_SHUFFLE, MVT::v16i8, Custom);
// Vector truncates to sub-word integer that fit in an Altivec/VSX register
// are cheap, so handle them before they get expanded to scalar.
setOperationAction(ISD::TRUNCATE, MVT::v8i8, Custom);
setOperationAction(ISD::TRUNCATE, MVT::v4i8, Custom);
setOperationAction(ISD::TRUNCATE, MVT::v2i8, Custom);
setOperationAction(ISD::TRUNCATE, MVT::v4i16, Custom);
setOperationAction(ISD::TRUNCATE, MVT::v2i16, Custom);
setOperationAction(ISD::AND , MVT::v4i32, Legal);
setOperationAction(ISD::OR , MVT::v4i32, Legal);
setOperationAction(ISD::XOR , MVT::v4i32, Legal);
setOperationAction(ISD::LOAD , MVT::v4i32, Legal);
setOperationAction(ISD::SELECT, MVT::v4i32,
Subtarget.useCRBits() ? Legal : Expand);
setOperationAction(ISD::STORE , MVT::v4i32, Legal);
setOperationAction(ISD::STRICT_FP_TO_SINT, MVT::v4i32, Legal);
setOperationAction(ISD::STRICT_FP_TO_UINT, MVT::v4i32, Legal);
setOperationAction(ISD::STRICT_SINT_TO_FP, MVT::v4i32, Legal);
setOperationAction(ISD::STRICT_UINT_TO_FP, MVT::v4i32, Legal);
setOperationAction(ISD::FP_TO_SINT, MVT::v4i32, Legal);
setOperationAction(ISD::FP_TO_UINT, MVT::v4i32, Legal);
setOperationAction(ISD::SINT_TO_FP, MVT::v4i32, Legal);
setOperationAction(ISD::UINT_TO_FP, MVT::v4i32, Legal);
setOperationAction(ISD::FFLOOR, MVT::v4f32, Legal);
setOperationAction(ISD::FCEIL, MVT::v4f32, Legal);
setOperationAction(ISD::FTRUNC, MVT::v4f32, Legal);
setOperationAction(ISD::FNEARBYINT, MVT::v4f32, Legal);
// Custom lowering ROTL v1i128 to VECTOR_SHUFFLE v16i8.
setOperationAction(ISD::ROTL, MVT::v1i128, Custom);
// With hasAltivec set, we can lower ISD::ROTL to vrl(b|h|w).
if (Subtarget.hasAltivec())
for (auto VT : {MVT::v4i32, MVT::v8i16, MVT::v16i8})
setOperationAction(ISD::ROTL, VT, Legal);
// With hasP8Altivec set, we can lower ISD::ROTL to vrld.
if (Subtarget.hasP8Altivec())
setOperationAction(ISD::ROTL, MVT::v2i64, Legal);
addRegisterClass(MVT::v4f32, &PPC::VRRCRegClass);
addRegisterClass(MVT::v4i32, &PPC::VRRCRegClass);
addRegisterClass(MVT::v8i16, &PPC::VRRCRegClass);
addRegisterClass(MVT::v16i8, &PPC::VRRCRegClass);
setOperationAction(ISD::MUL, MVT::v4f32, Legal);
setOperationAction(ISD::FMA, MVT::v4f32, Legal);
if (Subtarget.hasVSX()) {
setOperationAction(ISD::FDIV, MVT::v4f32, Legal);
setOperationAction(ISD::FSQRT, MVT::v4f32, Legal);
setOperationAction(ISD::INSERT_VECTOR_ELT, MVT::v2f64, Custom);
}
if (Subtarget.hasP8Altivec())
setOperationAction(ISD::MUL, MVT::v4i32, Legal);
else
setOperationAction(ISD::MUL, MVT::v4i32, Custom);
if (Subtarget.isISA3_1()) {
setOperationAction(ISD::MUL, MVT::v2i64, Legal);
setOperationAction(ISD::MULHS, MVT::v2i64, Legal);
setOperationAction(ISD::MULHU, MVT::v2i64, Legal);
setOperationAction(ISD::MULHS, MVT::v4i32, Legal);
setOperationAction(ISD::MULHU, MVT::v4i32, Legal);
setOperationAction(ISD::UDIV, MVT::v2i64, Legal);
setOperationAction(ISD::SDIV, MVT::v2i64, Legal);
setOperationAction(ISD::UDIV, MVT::v4i32, Legal);
setOperationAction(ISD::SDIV, MVT::v4i32, Legal);
setOperationAction(ISD::UREM, MVT::v2i64, Legal);
setOperationAction(ISD::SREM, MVT::v2i64, Legal);
setOperationAction(ISD::UREM, MVT::v4i32, Legal);
setOperationAction(ISD::SREM, MVT::v4i32, Legal);
setOperationAction(ISD::UREM, MVT::v1i128, Legal);
setOperationAction(ISD::SREM, MVT::v1i128, Legal);
setOperationAction(ISD::UDIV, MVT::v1i128, Legal);
setOperationAction(ISD::SDIV, MVT::v1i128, Legal);
setOperationAction(ISD::ROTL, MVT::v1i128, Legal);
}
setOperationAction(ISD::MUL, MVT::v8i16, Legal);
setOperationAction(ISD::MUL, MVT::v16i8, Custom);
setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v4f32, Custom);
setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v4i32, Custom);
setOperationAction(ISD::BUILD_VECTOR, MVT::v16i8, Custom);
setOperationAction(ISD::BUILD_VECTOR, MVT::v8i16, Custom);
setOperationAction(ISD::BUILD_VECTOR, MVT::v4i32, Custom);
setOperationAction(ISD::BUILD_VECTOR, MVT::v4f32, Custom);
// Altivec does not contain unordered floating-point compare instructions
setCondCodeAction(ISD::SETUO, MVT::v4f32, Expand);
setCondCodeAction(ISD::SETUEQ, MVT::v4f32, Expand);
setCondCodeAction(ISD::SETO, MVT::v4f32, Expand);
setCondCodeAction(ISD::SETONE, MVT::v4f32, Expand);
if (Subtarget.hasVSX()) {
setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v2f64, Legal);
setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2f64, Legal);
if (Subtarget.hasP8Vector()) {
setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v4f32, Legal);
setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4f32, Legal);
}
if (Subtarget.hasDirectMove() && isPPC64) {
setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v16i8, Legal);
setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v8i16, Legal);
setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v4i32, Legal);
setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v2i64, Legal);
setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v16i8, Legal);
setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v8i16, Legal);
setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4i32, Legal);
setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2i64, Legal);
}
setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2f64, Legal);
// The nearbyint variants are not allowed to raise the inexact exception
// so we can only code-gen them with unsafe math.
if (TM.Options.UnsafeFPMath) {
setOperationAction(ISD::FNEARBYINT, MVT::f64, Legal);
setOperationAction(ISD::FNEARBYINT, MVT::f32, Legal);
}
setOperationAction(ISD::FFLOOR, MVT::v2f64, Legal);
setOperationAction(ISD::FCEIL, MVT::v2f64, Legal);
setOperationAction(ISD::FTRUNC, MVT::v2f64, Legal);
setOperationAction(ISD::FNEARBYINT, MVT::v2f64, Legal);
setOperationAction(ISD::FRINT, MVT::v2f64, Legal);
setOperationAction(ISD::FROUND, MVT::v2f64, Legal);
setOperationAction(ISD::FROUND, MVT::f64, Legal);
setOperationAction(ISD::FRINT, MVT::f64, Legal);
setOperationAction(ISD::FNEARBYINT, MVT::v4f32, Legal);
setOperationAction(ISD::FRINT, MVT::v4f32, Legal);
setOperationAction(ISD::FROUND, MVT::v4f32, Legal);
setOperationAction(ISD::FROUND, MVT::f32, Legal);
setOperationAction(ISD::FRINT, MVT::f32, Legal);
setOperationAction(ISD::MUL, MVT::v2f64, Legal);
setOperationAction(ISD::FMA, MVT::v2f64, Legal);
setOperationAction(ISD::FDIV, MVT::v2f64, Legal);
setOperationAction(ISD::FSQRT, MVT::v2f64, Legal);
// Share the Altivec comparison restrictions.
setCondCodeAction(ISD::SETUO, MVT::v2f64, Expand);
setCondCodeAction(ISD::SETUEQ, MVT::v2f64, Expand);
setCondCodeAction(ISD::SETO, MVT::v2f64, Expand);
setCondCodeAction(ISD::SETONE, MVT::v2f64, Expand);
setOperationAction(ISD::LOAD, MVT::v2f64, Legal);
setOperationAction(ISD::STORE, MVT::v2f64, Legal);
setOperationAction(ISD::VECTOR_SHUFFLE, MVT::v2f64, Legal);
if (Subtarget.hasP8Vector())
addRegisterClass(MVT::f32, &PPC::VSSRCRegClass);
addRegisterClass(MVT::f64, &PPC::VSFRCRegClass);
addRegisterClass(MVT::v4i32, &PPC::VSRCRegClass);
addRegisterClass(MVT::v4f32, &PPC::VSRCRegClass);
addRegisterClass(MVT::v2f64, &PPC::VSRCRegClass);
if (Subtarget.hasP8Altivec()) {
setOperationAction(ISD::SHL, MVT::v2i64, Legal);
setOperationAction(ISD::SRA, MVT::v2i64, Legal);
setOperationAction(ISD::SRL, MVT::v2i64, Legal);
// 128 bit shifts can be accomplished via 3 instructions for SHL and
// SRL, but not for SRA because of the instructions available:
// VS{RL} and VS{RL}O. However due to direct move costs, it's not worth
// doing
setOperationAction(ISD::SHL, MVT::v1i128, Expand);
setOperationAction(ISD::SRL, MVT::v1i128, Expand);
setOperationAction(ISD::SRA, MVT::v1i128, Expand);
setOperationAction(ISD::SETCC, MVT::v2i64, Legal);
}
else {
setOperationAction(ISD::SHL, MVT::v2i64, Expand);
setOperationAction(ISD::SRA, MVT::v2i64, Expand);
setOperationAction(ISD::SRL, MVT::v2i64, Expand);
setOperationAction(ISD::SETCC, MVT::v2i64, Custom);
// VSX v2i64 only supports non-arithmetic operations.
setOperationAction(ISD::ADD, MVT::v2i64, Expand);
setOperationAction(ISD::SUB, MVT::v2i64, Expand);
}
if (Subtarget.isISA3_1())
setOperationAction(ISD::SETCC, MVT::v1i128, Legal);
else
setOperationAction(ISD::SETCC, MVT::v1i128, Expand);
setOperationAction(ISD::LOAD, MVT::v2i64, Promote);
AddPromotedToType (ISD::LOAD, MVT::v2i64, MVT::v2f64);
setOperationAction(ISD::STORE, MVT::v2i64, Promote);
AddPromotedToType (ISD::STORE, MVT::v2i64, MVT::v2f64);
setOperationAction(ISD::VECTOR_SHUFFLE, MVT::v2i64, Legal);
setOperationAction(ISD::STRICT_SINT_TO_FP, MVT::v2i64, Legal);
setOperationAction(ISD::STRICT_UINT_TO_FP, MVT::v2i64, Legal);
setOperationAction(ISD::STRICT_FP_TO_SINT, MVT::v2i64, Legal);
setOperationAction(ISD::STRICT_FP_TO_UINT, MVT::v2i64, Legal);
setOperationAction(ISD::SINT_TO_FP, MVT::v2i64, Legal);
setOperationAction(ISD::UINT_TO_FP, MVT::v2i64, Legal);
setOperationAction(ISD::FP_TO_SINT, MVT::v2i64, Legal);
setOperationAction(ISD::FP_TO_UINT, MVT::v2i64, Legal);
// Custom handling for partial vectors of integers converted to
// floating point. We already have optimal handling for v2i32 through
// the DAG combine, so those aren't necessary.
setOperationAction(ISD::STRICT_UINT_TO_FP, MVT::v2i8, Custom);
setOperationAction(ISD::STRICT_UINT_TO_FP, MVT::v4i8, Custom);
setOperationAction(ISD::STRICT_UINT_TO_FP, MVT::v2i16, Custom);
setOperationAction(ISD::STRICT_UINT_TO_FP, MVT::v4i16, Custom);
setOperationAction(ISD::STRICT_SINT_TO_FP, MVT::v2i8, Custom);
setOperationAction(ISD::STRICT_SINT_TO_FP, MVT::v4i8, Custom);
setOperationAction(ISD::STRICT_SINT_TO_FP, MVT::v2i16, Custom);
setOperationAction(ISD::STRICT_SINT_TO_FP, MVT::v4i16, Custom);
setOperationAction(ISD::UINT_TO_FP, MVT::v2i8, Custom);
setOperationAction(ISD::UINT_TO_FP, MVT::v4i8, Custom);
setOperationAction(ISD::UINT_TO_FP, MVT::v2i16, Custom);
setOperationAction(ISD::UINT_TO_FP, MVT::v4i16, Custom);
setOperationAction(ISD::SINT_TO_FP, MVT::v2i8, Custom);
setOperationAction(ISD::SINT_TO_FP, MVT::v4i8, Custom);
setOperationAction(ISD::SINT_TO_FP, MVT::v2i16, Custom);
setOperationAction(ISD::SINT_TO_FP, MVT::v4i16, Custom);
setOperationAction(ISD::FNEG, MVT::v4f32, Legal);
setOperationAction(ISD::FNEG, MVT::v2f64, Legal);
setOperationAction(ISD::FABS, MVT::v4f32, Legal);
setOperationAction(ISD::FABS, MVT::v2f64, Legal);
setOperationAction(ISD::FCOPYSIGN, MVT::v4f32, Legal);
setOperationAction(ISD::FCOPYSIGN, MVT::v2f64, Legal);
setOperationAction(ISD::BUILD_VECTOR, MVT::v2i64, Custom);
setOperationAction(ISD::BUILD_VECTOR, MVT::v2f64, Custom);
// Handle constrained floating-point operations of vector.
// The predictor is `hasVSX` because altivec instruction has
// no exception but VSX vector instruction has.
setOperationAction(ISD::STRICT_FADD, MVT::v4f32, Legal);
setOperationAction(ISD::STRICT_FSUB, MVT::v4f32, Legal);
setOperationAction(ISD::STRICT_FMUL, MVT::v4f32, Legal);
setOperationAction(ISD::STRICT_FDIV, MVT::v4f32, Legal);
setOperationAction(ISD::STRICT_FMA, MVT::v4f32, Legal);
setOperationAction(ISD::STRICT_FSQRT, MVT::v4f32, Legal);
setOperationAction(ISD::STRICT_FMAXNUM, MVT::v4f32, Legal);
setOperationAction(ISD::STRICT_FMINNUM, MVT::v4f32, Legal);
setOperationAction(ISD::STRICT_FRINT, MVT::v4f32, Legal);
setOperationAction(ISD::STRICT_FFLOOR, MVT::v4f32, Legal);
setOperationAction(ISD::STRICT_FCEIL, MVT::v4f32, Legal);
setOperationAction(ISD::STRICT_FTRUNC, MVT::v4f32, Legal);
setOperationAction(ISD::STRICT_FROUND, MVT::v4f32, Legal);
setOperationAction(ISD::STRICT_FADD, MVT::v2f64, Legal);
setOperationAction(ISD::STRICT_FSUB, MVT::v2f64, Legal);
setOperationAction(ISD::STRICT_FMUL, MVT::v2f64, Legal);
setOperationAction(ISD::STRICT_FDIV, MVT::v2f64, Legal);
setOperationAction(ISD::STRICT_FMA, MVT::v2f64, Legal);
setOperationAction(ISD::STRICT_FSQRT, MVT::v2f64, Legal);
setOperationAction(ISD::STRICT_FMAXNUM, MVT::v2f64, Legal);
setOperationAction(ISD::STRICT_FMINNUM, MVT::v2f64, Legal);
setOperationAction(ISD::STRICT_FRINT, MVT::v2f64, Legal);
setOperationAction(ISD::STRICT_FFLOOR, MVT::v2f64, Legal);
setOperationAction(ISD::STRICT_FCEIL, MVT::v2f64, Legal);
setOperationAction(ISD::STRICT_FTRUNC, MVT::v2f64, Legal);
setOperationAction(ISD::STRICT_FROUND, MVT::v2f64, Legal);
addRegisterClass(MVT::v2i64, &PPC::VSRCRegClass);
addRegisterClass(MVT::f128, &PPC::VRRCRegClass);
for (MVT FPT : MVT::fp_valuetypes())
setLoadExtAction(ISD::EXTLOAD, MVT::f128, FPT, Expand);
// Expand the SELECT to SELECT_CC
setOperationAction(ISD::SELECT, MVT::f128, Expand);
setTruncStoreAction(MVT::f128, MVT::f64, Expand);
setTruncStoreAction(MVT::f128, MVT::f32, Expand);
// No implementation for these ops for PowerPC.
setOperationAction(ISD::FSIN, MVT::f128, Expand);
setOperationAction(ISD::FCOS, MVT::f128, Expand);
setOperationAction(ISD::FPOW, MVT::f128, Expand);
setOperationAction(ISD::FPOWI, MVT::f128, Expand);
setOperationAction(ISD::FREM, MVT::f128, Expand);
}
if (Subtarget.hasP8Altivec()) {
addRegisterClass(MVT::v2i64, &PPC::VRRCRegClass);
addRegisterClass(MVT::v1i128, &PPC::VRRCRegClass);
}
if (Subtarget.hasP9Vector()) {
setOperationAction(ISD::INSERT_VECTOR_ELT, MVT::v4i32, Custom);
setOperationAction(ISD::INSERT_VECTOR_ELT, MVT::v4f32, Custom);
// 128 bit shifts can be accomplished via 3 instructions for SHL and
// SRL, but not for SRA because of the instructions available:
// VS{RL} and VS{RL}O.
setOperationAction(ISD::SHL, MVT::v1i128, Legal);
setOperationAction(ISD::SRL, MVT::v1i128, Legal);
setOperationAction(ISD::SRA, MVT::v1i128, Expand);
setOperationAction(ISD::FADD, MVT::f128, Legal);
setOperationAction(ISD::FSUB, MVT::f128, Legal);
setOperationAction(ISD::FDIV, MVT::f128, Legal);
setOperationAction(ISD::FMUL, MVT::f128, Legal);
setOperationAction(ISD::FP_EXTEND, MVT::f128, Legal);
setOperationAction(ISD::FMA, MVT::f128, Legal);
setCondCodeAction(ISD::SETULT, MVT::f128, Expand);
setCondCodeAction(ISD::SETUGT, MVT::f128, Expand);
setCondCodeAction(ISD::SETUEQ, MVT::f128, Expand);
setCondCodeAction(ISD::SETOGE, MVT::f128, Expand);
setCondCodeAction(ISD::SETOLE, MVT::f128, Expand);
setCondCodeAction(ISD::SETONE, MVT::f128, Expand);
setOperationAction(ISD::FTRUNC, MVT::f128, Legal);
setOperationAction(ISD::FRINT, MVT::f128, Legal);
setOperationAction(ISD::FFLOOR, MVT::f128, Legal);
setOperationAction(ISD::FCEIL, MVT::f128, Legal);
setOperationAction(ISD::FNEARBYINT, MVT::f128, Legal);
setOperationAction(ISD::FROUND, MVT::f128, Legal);
setOperationAction(ISD::FP_ROUND, MVT::f64, Legal);
setOperationAction(ISD::FP_ROUND, MVT::f32, Legal);
setOperationAction(ISD::BITCAST, MVT::i128, Custom);
// Handle constrained floating-point operations of fp128
setOperationAction(ISD::STRICT_FADD, MVT::f128, Legal);
setOperationAction(ISD::STRICT_FSUB, MVT::f128, Legal);
setOperationAction(ISD::STRICT_FMUL, MVT::f128, Legal);
setOperationAction(ISD::STRICT_FDIV, MVT::f128, Legal);
setOperationAction(ISD::STRICT_FMA, MVT::f128, Legal);
setOperationAction(ISD::STRICT_FSQRT, MVT::f128, Legal);
setOperationAction(ISD::STRICT_FP_EXTEND, MVT::f128, Legal);
setOperationAction(ISD::STRICT_FP_ROUND, MVT::f64, Legal);
setOperationAction(ISD::STRICT_FP_ROUND, MVT::f32, Legal);
setOperationAction(ISD::STRICT_FRINT, MVT::f128, Legal);
setOperationAction(ISD::STRICT_FNEARBYINT, MVT::f128, Legal);
setOperationAction(ISD::STRICT_FFLOOR, MVT::f128, Legal);
setOperationAction(ISD::STRICT_FCEIL, MVT::f128, Legal);
setOperationAction(ISD::STRICT_FTRUNC, MVT::f128, Legal);
setOperationAction(ISD::STRICT_FROUND, MVT::f128, Legal);
setOperationAction(ISD::FP_EXTEND, MVT::v2f32, Custom);
setOperationAction(ISD::BSWAP, MVT::v8i16, Legal);
setOperationAction(ISD::BSWAP, MVT::v4i32, Legal);
setOperationAction(ISD::BSWAP, MVT::v2i64, Legal);
setOperationAction(ISD::BSWAP, MVT::v1i128, Legal);
} else if (Subtarget.hasVSX()) {
setOperationAction(ISD::LOAD, MVT::f128, Promote);
setOperationAction(ISD::STORE, MVT::f128, Promote);
AddPromotedToType(ISD::LOAD, MVT::f128, MVT::v4i32);
AddPromotedToType(ISD::STORE, MVT::f128, MVT::v4i32);
// Set FADD/FSUB as libcall to avoid the legalizer to expand the
// fp_to_uint and int_to_fp.
setOperationAction(ISD::FADD, MVT::f128, LibCall);
setOperationAction(ISD::FSUB, MVT::f128, LibCall);
setOperationAction(ISD::FMUL, MVT::f128, Expand);
setOperationAction(ISD::FDIV, MVT::f128, Expand);
setOperationAction(ISD::FNEG, MVT::f128, Expand);
setOperationAction(ISD::FABS, MVT::f128, Expand);
setOperationAction(ISD::FSQRT, MVT::f128, Expand);
setOperationAction(ISD::FMA, MVT::f128, Expand);
setOperationAction(ISD::FCOPYSIGN, MVT::f128, Expand);
// Expand the fp_extend if the target type is fp128.
setOperationAction(ISD::FP_EXTEND, MVT::f128, Expand);
setOperationAction(ISD::STRICT_FP_EXTEND, MVT::f128, Expand);
// Expand the fp_round if the source type is fp128.
for (MVT VT : {MVT::f32, MVT::f64}) {
setOperationAction(ISD::FP_ROUND, VT, Custom);
setOperationAction(ISD::STRICT_FP_ROUND, VT, Custom);
}
setOperationAction(ISD::SETCC, MVT::f128, Custom);
setOperationAction(ISD::STRICT_FSETCC, MVT::f128, Custom);
setOperationAction(ISD::STRICT_FSETCCS, MVT::f128, Custom);
setOperationAction(ISD::BR_CC, MVT::f128, Expand);
// Lower following f128 select_cc pattern:
// select_cc x, y, tv, fv, cc -> select_cc (setcc x, y, cc), 0, tv, fv, NE
setOperationAction(ISD::SELECT_CC, MVT::f128, Custom);
// We need to handle f128 SELECT_CC with integer result type.
setOperationAction(ISD::SELECT_CC, MVT::i32, Custom);
setOperationAction(ISD::SELECT_CC, MVT::i64, isPPC64 ? Custom : Expand);
}
if (Subtarget.hasP9Altivec()) {
if (Subtarget.isISA3_1()) {
setOperationAction(ISD::INSERT_VECTOR_ELT, MVT::v2i64, Legal);
setOperationAction(ISD::INSERT_VECTOR_ELT, MVT::v8i16, Legal);
setOperationAction(ISD::INSERT_VECTOR_ELT, MVT::v16i8, Legal);
setOperationAction(ISD::INSERT_VECTOR_ELT, MVT::v4i32, Legal);
} else {
setOperationAction(ISD::INSERT_VECTOR_ELT, MVT::v8i16, Custom);
setOperationAction(ISD::INSERT_VECTOR_ELT, MVT::v16i8, Custom);
}
setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::v4i8, Legal);
setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::v4i16, Legal);
setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::v4i32, Legal);
setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::v2i8, Legal);
setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::v2i16, Legal);
setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::v2i32, Legal);
setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::v2i64, Legal);
}
}
if (Subtarget.pairedVectorMemops()) {
addRegisterClass(MVT::v256i1, &PPC::VSRpRCRegClass);
setOperationAction(ISD::LOAD, MVT::v256i1, Custom);
setOperationAction(ISD::STORE, MVT::v256i1, Custom);
}
if (Subtarget.hasMMA()) {
addRegisterClass(MVT::v512i1, &PPC::UACCRCRegClass);
setOperationAction(ISD::LOAD, MVT::v512i1, Custom);
setOperationAction(ISD::STORE, MVT::v512i1, Custom);
setOperationAction(ISD::BUILD_VECTOR, MVT::v512i1, Custom);
}
if (Subtarget.has64BitSupport())
setOperationAction(ISD::PREFETCH, MVT::Other, Legal);
if (Subtarget.isISA3_1())
setOperationAction(ISD::SRA, MVT::v1i128, Legal);
setOperationAction(ISD::READCYCLECOUNTER, MVT::i64, isPPC64 ? Legal : Custom);
if (!isPPC64) {
setOperationAction(ISD::ATOMIC_LOAD, MVT::i64, Expand);
setOperationAction(ISD::ATOMIC_STORE, MVT::i64, Expand);
}
if (EnableQuadwordAtomics && Subtarget.hasQuadwordAtomics()) {
setMaxAtomicSizeInBitsSupported(128);
setOperationAction(ISD::ATOMIC_LOAD, MVT::i128, Custom);
setOperationAction(ISD::ATOMIC_STORE, MVT::i128, Custom);
setOperationAction(ISD::INTRINSIC_VOID, MVT::i128, Custom);
}
setBooleanContents(ZeroOrOneBooleanContent);
if (Subtarget.hasAltivec()) {
// Altivec instructions set fields to all zeros or all ones.
setBooleanVectorContents(ZeroOrNegativeOneBooleanContent);
}
if (!isPPC64) {
// These libcalls are not available in 32-bit.
setLibcallName(RTLIB::SHL_I128, nullptr);
setLibcallName(RTLIB::SRL_I128, nullptr);
setLibcallName(RTLIB::SRA_I128, nullptr);
+ setLibcallName(RTLIB::MUL_I128, nullptr);
setLibcallName(RTLIB::MULO_I64, nullptr);
+ setLibcallName(RTLIB::MULO_I128, nullptr);
}
if (!isPPC64)
setMaxAtomicSizeInBitsSupported(32);
setStackPointerRegisterToSaveRestore(isPPC64 ? PPC::X1 : PPC::R1);
// We have target-specific dag combine patterns for the following nodes:
setTargetDAGCombine(ISD::ADD);
setTargetDAGCombine(ISD::SHL);
setTargetDAGCombine(ISD::SRA);
setTargetDAGCombine(ISD::SRL);
setTargetDAGCombine(ISD::MUL);
setTargetDAGCombine(ISD::FMA);
setTargetDAGCombine(ISD::SINT_TO_FP);
setTargetDAGCombine(ISD::BUILD_VECTOR);
if (Subtarget.hasFPCVT())
setTargetDAGCombine(ISD::UINT_TO_FP);
setTargetDAGCombine(ISD::LOAD);
setTargetDAGCombine(ISD::STORE);
setTargetDAGCombine(ISD::BR_CC);
if (Subtarget.useCRBits())
setTargetDAGCombine(ISD::BRCOND);
setTargetDAGCombine(ISD::BSWAP);
setTargetDAGCombine(ISD::INTRINSIC_WO_CHAIN);
setTargetDAGCombine(ISD::INTRINSIC_W_CHAIN);
setTargetDAGCombine(ISD::INTRINSIC_VOID);
setTargetDAGCombine(ISD::SIGN_EXTEND);
setTargetDAGCombine(ISD::ZERO_EXTEND);
setTargetDAGCombine(ISD::ANY_EXTEND);
setTargetDAGCombine(ISD::TRUNCATE);
setTargetDAGCombine(ISD::VECTOR_SHUFFLE);
if (Subtarget.useCRBits()) {
setTargetDAGCombine(ISD::TRUNCATE);
setTargetDAGCombine(ISD::SETCC);
setTargetDAGCombine(ISD::SELECT_CC);
}
if (Subtarget.hasP9Altivec()) {
setTargetDAGCombine(ISD::ABS);
setTargetDAGCombine(ISD::VSELECT);
}
setLibcallName(RTLIB::LOG_F128, "logf128");
setLibcallName(RTLIB::LOG2_F128, "log2f128");
setLibcallName(RTLIB::LOG10_F128, "log10f128");
setLibcallName(RTLIB::EXP_F128, "expf128");
setLibcallName(RTLIB::EXP2_F128, "exp2f128");
setLibcallName(RTLIB::SIN_F128, "sinf128");
setLibcallName(RTLIB::COS_F128, "cosf128");
setLibcallName(RTLIB::POW_F128, "powf128");
setLibcallName(RTLIB::FMIN_F128, "fminf128");
setLibcallName(RTLIB::FMAX_F128, "fmaxf128");
setLibcallName(RTLIB::REM_F128, "fmodf128");
setLibcallName(RTLIB::SQRT_F128, "sqrtf128");
setLibcallName(RTLIB::CEIL_F128, "ceilf128");
setLibcallName(RTLIB::FLOOR_F128, "floorf128");
setLibcallName(RTLIB::TRUNC_F128, "truncf128");
setLibcallName(RTLIB::ROUND_F128, "roundf128");
setLibcallName(RTLIB::LROUND_F128, "lroundf128");
setLibcallName(RTLIB::LLROUND_F128, "llroundf128");
setLibcallName(RTLIB::RINT_F128, "rintf128");
setLibcallName(RTLIB::LRINT_F128, "lrintf128");
setLibcallName(RTLIB::LLRINT_F128, "llrintf128");
setLibcallName(RTLIB::NEARBYINT_F128, "nearbyintf128");
setLibcallName(RTLIB::FMA_F128, "fmaf128");
// With 32 condition bits, we don't need to sink (and duplicate) compares
// aggressively in CodeGenPrep.
if (Subtarget.useCRBits()) {
setHasMultipleConditionRegisters();
setJumpIsExpensive();
}
setMinFunctionAlignment(Align(4));
switch (Subtarget.getCPUDirective()) {
default: break;
case PPC::DIR_970:
case PPC::DIR_A2:
case PPC::DIR_E500:
case PPC::DIR_E500mc:
case PPC::DIR_E5500:
case PPC::DIR_PWR4:
case PPC::DIR_PWR5:
case PPC::DIR_PWR5X:
case PPC::DIR_PWR6:
case PPC::DIR_PWR6X:
case PPC::DIR_PWR7:
case PPC::DIR_PWR8:
case PPC::DIR_PWR9:
case PPC::DIR_PWR10:
case PPC::DIR_PWR_FUTURE:
setPrefLoopAlignment(Align(16));
setPrefFunctionAlignment(Align(16));
break;
}
if (Subtarget.enableMachineScheduler())
setSchedulingPreference(Sched::Source);
else
setSchedulingPreference(Sched::Hybrid);
computeRegisterProperties(STI.getRegisterInfo());
// The Freescale cores do better with aggressive inlining of memcpy and
// friends. GCC uses same threshold of 128 bytes (= 32 word stores).
if (Subtarget.getCPUDirective() == PPC::DIR_E500mc ||
Subtarget.getCPUDirective() == PPC::DIR_E5500) {
MaxStoresPerMemset = 32;
MaxStoresPerMemsetOptSize = 16;
MaxStoresPerMemcpy = 32;
MaxStoresPerMemcpyOptSize = 8;
MaxStoresPerMemmove = 32;
MaxStoresPerMemmoveOptSize = 8;
} else if (Subtarget.getCPUDirective() == PPC::DIR_A2) {
// The A2 also benefits from (very) aggressive inlining of memcpy and
// friends. The overhead of a the function call, even when warm, can be
// over one hundred cycles.
MaxStoresPerMemset = 128;
MaxStoresPerMemcpy = 128;
MaxStoresPerMemmove = 128;
MaxLoadsPerMemcmp = 128;
} else {
MaxLoadsPerMemcmp = 8;
MaxLoadsPerMemcmpOptSize = 4;
}
IsStrictFPEnabled = true;
// Let the subtarget (CPU) decide if a predictable select is more expensive
// than the corresponding branch. This information is used in CGP to decide
// when to convert selects into branches.
PredictableSelectIsExpensive = Subtarget.isPredictableSelectIsExpensive();
}
// *********************************** NOTE ************************************
// For selecting load and store instructions, the addressing modes are defined
// as ComplexPatterns in PPCInstrInfo.td, which are then utilized in the TD
// patterns to match the load the store instructions.
//
// The TD definitions for the addressing modes correspond to their respective
// Select<AddrMode>Form() function in PPCISelDAGToDAG.cpp. These functions rely
// on SelectOptimalAddrMode(), which calls computeMOFlags() to compute the
// address mode flags of a particular node. Afterwards, the computed address
// flags are passed into getAddrModeForFlags() in order to retrieve the optimal
// addressing mode. SelectOptimalAddrMode() then sets the Base and Displacement
// accordingly, based on the preferred addressing mode.
//
// Within PPCISelLowering.h, there are two enums: MemOpFlags and AddrMode.
// MemOpFlags contains all the possible flags that can be used to compute the
// optimal addressing mode for load and store instructions.
// AddrMode contains all the possible load and store addressing modes available
// on Power (such as DForm, DSForm, DQForm, XForm, etc.)
//
// When adding new load and store instructions, it is possible that new address
// flags may need to be added into MemOpFlags, and a new addressing mode will
// need to be added to AddrMode. An entry of the new addressing mode (consisting
// of the minimal and main distinguishing address flags for the new load/store
// instructions) will need to be added into initializeAddrModeMap() below.
// Finally, when adding new addressing modes, the getAddrModeForFlags() will
// need to be updated to account for selecting the optimal addressing mode.
// *****************************************************************************
/// Initialize the map that relates the different addressing modes of the load
/// and store instructions to a set of flags. This ensures the load/store
/// instruction is correctly matched during instruction selection.
void PPCTargetLowering::initializeAddrModeMap() {
AddrModesMap[PPC::AM_DForm] = {
// LWZ, STW
PPC::MOF_ZExt | PPC::MOF_RPlusSImm16 | PPC::MOF_WordInt,
PPC::MOF_ZExt | PPC::MOF_RPlusLo | PPC::MOF_WordInt,
PPC::MOF_ZExt | PPC::MOF_NotAddNorCst | PPC::MOF_WordInt,
PPC::MOF_ZExt | PPC::MOF_AddrIsSImm32 | PPC::MOF_WordInt,
// LBZ, LHZ, STB, STH
PPC::MOF_ZExt | PPC::MOF_RPlusSImm16 | PPC::MOF_SubWordInt,
PPC::MOF_ZExt | PPC::MOF_RPlusLo | PPC::MOF_SubWordInt,
PPC::MOF_ZExt | PPC::MOF_NotAddNorCst | PPC::MOF_SubWordInt,
PPC::MOF_ZExt | PPC::MOF_AddrIsSImm32 | PPC::MOF_SubWordInt,
// LHA
PPC::MOF_SExt | PPC::MOF_RPlusSImm16 | PPC::MOF_SubWordInt,
PPC::MOF_SExt | PPC::MOF_RPlusLo | PPC::MOF_SubWordInt,
PPC::MOF_SExt | PPC::MOF_NotAddNorCst | PPC::MOF_SubWordInt,
PPC::MOF_SExt | PPC::MOF_AddrIsSImm32 | PPC::MOF_SubWordInt,
// LFS, LFD, STFS, STFD
PPC::MOF_RPlusSImm16 | PPC::MOF_ScalarFloat | PPC::MOF_SubtargetBeforeP9,
PPC::MOF_RPlusLo | PPC::MOF_ScalarFloat | PPC::MOF_SubtargetBeforeP9,
PPC::MOF_NotAddNorCst | PPC::MOF_ScalarFloat | PPC::MOF_SubtargetBeforeP9,
PPC::MOF_AddrIsSImm32 | PPC::MOF_ScalarFloat | PPC::MOF_SubtargetBeforeP9,
};
AddrModesMap[PPC::AM_DSForm] = {
// LWA
PPC::MOF_SExt | PPC::MOF_RPlusSImm16Mult4 | PPC::MOF_WordInt,
PPC::MOF_SExt | PPC::MOF_NotAddNorCst | PPC::MOF_WordInt,
PPC::MOF_SExt | PPC::MOF_AddrIsSImm32 | PPC::MOF_WordInt,
// LD, STD
PPC::MOF_RPlusSImm16Mult4 | PPC::MOF_DoubleWordInt,
PPC::MOF_NotAddNorCst | PPC::MOF_DoubleWordInt,
PPC::MOF_AddrIsSImm32 | PPC::MOF_DoubleWordInt,
// DFLOADf32, DFLOADf64, DSTOREf32, DSTOREf64
PPC::MOF_RPlusSImm16Mult4 | PPC::MOF_ScalarFloat | PPC::MOF_SubtargetP9,
PPC::MOF_NotAddNorCst | PPC::MOF_ScalarFloat | PPC::MOF_SubtargetP9,
PPC::MOF_AddrIsSImm32 | PPC::MOF_ScalarFloat | PPC::MOF_SubtargetP9,
};
AddrModesMap[PPC::AM_DQForm] = {
// LXV, STXV
PPC::MOF_RPlusSImm16Mult16 | PPC::MOF_Vector | PPC::MOF_SubtargetP9,
PPC::MOF_NotAddNorCst | PPC::MOF_Vector | PPC::MOF_SubtargetP9,
PPC::MOF_AddrIsSImm32 | PPC::MOF_Vector | PPC::MOF_SubtargetP9,
};
AddrModesMap[PPC::AM_PrefixDForm] = {PPC::MOF_RPlusSImm34 |
PPC::MOF_SubtargetP10};
// TODO: Add mapping for quadword load/store.
}
/// getMaxByValAlign - Helper for getByValTypeAlignment to determine
/// the desired ByVal argument alignment.
static void getMaxByValAlign(Type *Ty, Align &MaxAlign, Align MaxMaxAlign) {
if (MaxAlign == MaxMaxAlign)
return;
if (VectorType *VTy = dyn_cast<VectorType>(Ty)) {
if (MaxMaxAlign >= 32 &&
VTy->getPrimitiveSizeInBits().getFixedSize() >= 256)
MaxAlign = Align(32);
else if (VTy->getPrimitiveSizeInBits().getFixedSize() >= 128 &&
MaxAlign < 16)
MaxAlign = Align(16);
} else if (ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
Align EltAlign;
getMaxByValAlign(ATy->getElementType(), EltAlign, MaxMaxAlign);
if (EltAlign > MaxAlign)
MaxAlign = EltAlign;
} else if (StructType *STy = dyn_cast<StructType>(Ty)) {
for (auto *EltTy : STy->elements()) {
Align EltAlign;
getMaxByValAlign(EltTy, EltAlign, MaxMaxAlign);
if (EltAlign > MaxAlign)
MaxAlign = EltAlign;
if (MaxAlign == MaxMaxAlign)
break;
}
}
}
/// getByValTypeAlignment - Return the desired alignment for ByVal aggregate
/// function arguments in the caller parameter area.
uint64_t PPCTargetLowering::getByValTypeAlignment(Type *Ty,
const DataLayout &DL) const {
// 16byte and wider vectors are passed on 16byte boundary.
// The rest is 8 on PPC64 and 4 on PPC32 boundary.
Align Alignment = Subtarget.isPPC64() ? Align(8) : Align(4);
if (Subtarget.hasAltivec())
getMaxByValAlign(Ty, Alignment, Align(16));
return Alignment.value();
}
bool PPCTargetLowering::useSoftFloat() const {
return Subtarget.useSoftFloat();
}
bool PPCTargetLowering::hasSPE() const {
return Subtarget.hasSPE();
}
bool PPCTargetLowering::preferIncOfAddToSubOfNot(EVT VT) const {
return VT.isScalarInteger();
}
const char *PPCTargetLowering::getTargetNodeName(unsigned Opcode) const {
switch ((PPCISD::NodeType)Opcode) {
case PPCISD::FIRST_NUMBER: break;
case PPCISD::FSEL: return "PPCISD::FSEL";
case PPCISD::XSMAXCDP: return "PPCISD::XSMAXCDP";
case PPCISD::XSMINCDP: return "PPCISD::XSMINCDP";
case PPCISD::FCFID: return "PPCISD::FCFID";
case PPCISD::FCFIDU: return "PPCISD::FCFIDU";
case PPCISD::FCFIDS: return "PPCISD::FCFIDS";
case PPCISD::FCFIDUS: return "PPCISD::FCFIDUS";
case PPCISD::FCTIDZ: return "PPCISD::FCTIDZ";
case PPCISD::FCTIWZ: return "PPCISD::FCTIWZ";
case PPCISD::FCTIDUZ: return "PPCISD::FCTIDUZ";
case PPCISD::FCTIWUZ: return "PPCISD::FCTIWUZ";
case PPCISD::FP_TO_UINT_IN_VSR:
return "PPCISD::FP_TO_UINT_IN_VSR,";
case PPCISD::FP_TO_SINT_IN_VSR:
return "PPCISD::FP_TO_SINT_IN_VSR";
case PPCISD::FRE: return "PPCISD::FRE";
case PPCISD::FRSQRTE: return "PPCISD::FRSQRTE";
case PPCISD::FTSQRT:
return "PPCISD::FTSQRT";
case PPCISD::FSQRT:
return "PPCISD::FSQRT";
case PPCISD::STFIWX: return "PPCISD::STFIWX";
case PPCISD::VPERM: return "PPCISD::VPERM";
case PPCISD::XXSPLT: return "PPCISD::XXSPLT";
case PPCISD::XXSPLTI_SP_TO_DP:
return "PPCISD::XXSPLTI_SP_TO_DP";
case PPCISD::XXSPLTI32DX:
return "PPCISD::XXSPLTI32DX";
case PPCISD::VECINSERT: return "PPCISD::VECINSERT";
case PPCISD::XXPERMDI: return "PPCISD::XXPERMDI";
case PPCISD::VECSHL: return "PPCISD::VECSHL";
case PPCISD::CMPB: return "PPCISD::CMPB";
case PPCISD::Hi: return "PPCISD::Hi";
case PPCISD::Lo: return "PPCISD::Lo";
case PPCISD::TOC_ENTRY: return "PPCISD::TOC_ENTRY";
case PPCISD::ATOMIC_CMP_SWAP_8: return "PPCISD::ATOMIC_CMP_SWAP_8";
case PPCISD::ATOMIC_CMP_SWAP_16: return "PPCISD::ATOMIC_CMP_SWAP_16";
case PPCISD::DYNALLOC: return "PPCISD::DYNALLOC";
case PPCISD::DYNAREAOFFSET: return "PPCISD::DYNAREAOFFSET";
case PPCISD::PROBED_ALLOCA: return "PPCISD::PROBED_ALLOCA";
case PPCISD::GlobalBaseReg: return "PPCISD::GlobalBaseReg";
case PPCISD::SRL: return "PPCISD::SRL";
case PPCISD::SRA: return "PPCISD::SRA";
case PPCISD::SHL: return "PPCISD::SHL";
case PPCISD::SRA_ADDZE: return "PPCISD::SRA_ADDZE";
case PPCISD::CALL: return "PPCISD::CALL";
case PPCISD::CALL_NOP: return "PPCISD::CALL_NOP";
case PPCISD::CALL_NOTOC: return "PPCISD::CALL_NOTOC";
case PPCISD::CALL_RM:
return "PPCISD::CALL_RM";
case PPCISD::CALL_NOP_RM:
return "PPCISD::CALL_NOP_RM";
case PPCISD::CALL_NOTOC_RM:
return "PPCISD::CALL_NOTOC_RM";
case PPCISD::MTCTR: return "PPCISD::MTCTR";
case PPCISD::BCTRL: return "PPCISD::BCTRL";
case PPCISD::BCTRL_LOAD_TOC: return "PPCISD::BCTRL_LOAD_TOC";
case PPCISD::BCTRL_RM:
return "PPCISD::BCTRL_RM";
case PPCISD::BCTRL_LOAD_TOC_RM:
return "PPCISD::BCTRL_LOAD_TOC_RM";
case PPCISD::RET_FLAG: return "PPCISD::RET_FLAG";
case PPCISD::READ_TIME_BASE: return "PPCISD::READ_TIME_BASE";
case PPCISD::EH_SJLJ_SETJMP: return "PPCISD::EH_SJLJ_SETJMP";
case PPCISD::EH_SJLJ_LONGJMP: return "PPCISD::EH_SJLJ_LONGJMP";
case PPCISD::MFOCRF: return "PPCISD::MFOCRF";
case PPCISD::MFVSR: return "PPCISD::MFVSR";
case PPCISD::MTVSRA: return "PPCISD::MTVSRA";
case PPCISD::MTVSRZ: return "PPCISD::MTVSRZ";
case PPCISD::SINT_VEC_TO_FP: return "PPCISD::SINT_VEC_TO_FP";
case PPCISD::UINT_VEC_TO_FP: return "PPCISD::UINT_VEC_TO_FP";
case PPCISD::SCALAR_TO_VECTOR_PERMUTED:
return "PPCISD::SCALAR_TO_VECTOR_PERMUTED";
case PPCISD::ANDI_rec_1_EQ_BIT:
return "PPCISD::ANDI_rec_1_EQ_BIT";
case PPCISD::ANDI_rec_1_GT_BIT:
return "PPCISD::ANDI_rec_1_GT_BIT";
case PPCISD::VCMP: return "PPCISD::VCMP";
case PPCISD::VCMP_rec: return "PPCISD::VCMP_rec";
case PPCISD::LBRX: return "PPCISD::LBRX";
case PPCISD::STBRX: return "PPCISD::STBRX";
case PPCISD::LFIWAX: return "PPCISD::LFIWAX";
case PPCISD::LFIWZX: return "PPCISD::LFIWZX";
case PPCISD::LXSIZX: return "PPCISD::LXSIZX";
case PPCISD::STXSIX: return "PPCISD::STXSIX";
case PPCISD::VEXTS: return "PPCISD::VEXTS";
case PPCISD::LXVD2X: return "PPCISD::LXVD2X";
case PPCISD::STXVD2X: return "PPCISD::STXVD2X";
case PPCISD::LOAD_VEC_BE: return "PPCISD::LOAD_VEC_BE";
case PPCISD::STORE_VEC_BE: return "PPCISD::STORE_VEC_BE";
case PPCISD::ST_VSR_SCAL_INT:
return "PPCISD::ST_VSR_SCAL_INT";
case PPCISD::COND_BRANCH: return "PPCISD::COND_BRANCH";
case PPCISD::BDNZ: return "PPCISD::BDNZ";
case PPCISD::BDZ: return "PPCISD::BDZ";
case PPCISD::MFFS: return "PPCISD::MFFS";
case PPCISD::FADDRTZ: return "PPCISD::FADDRTZ";
case PPCISD::TC_RETURN: return "PPCISD::TC_RETURN";
case PPCISD::CR6SET: return "PPCISD::CR6SET";
case PPCISD::CR6UNSET: return "PPCISD::CR6UNSET";
case PPCISD::PPC32_GOT: return "PPCISD::PPC32_GOT";
case PPCISD::PPC32_PICGOT: return "PPCISD::PPC32_PICGOT";
case PPCISD::ADDIS_GOT_TPREL_HA: return "PPCISD::ADDIS_GOT_TPREL_HA";
case PPCISD::LD_GOT_TPREL_L: return "PPCISD::LD_GOT_TPREL_L";
case PPCISD::ADD_TLS: return "PPCISD::ADD_TLS";
case PPCISD::ADDIS_TLSGD_HA: return "PPCISD::ADDIS_TLSGD_HA";
case PPCISD::ADDI_TLSGD_L: return "PPCISD::ADDI_TLSGD_L";
case PPCISD::GET_TLS_ADDR: return "PPCISD::GET_TLS_ADDR";
case PPCISD::ADDI_TLSGD_L_ADDR: return "PPCISD::ADDI_TLSGD_L_ADDR";
case PPCISD::TLSGD_AIX: return "PPCISD::TLSGD_AIX";
case PPCISD::ADDIS_TLSLD_HA: return "PPCISD::ADDIS_TLSLD_HA";
case PPCISD::ADDI_TLSLD_L: return "PPCISD::ADDI_TLSLD_L";
case PPCISD::GET_TLSLD_ADDR: return "PPCISD::GET_TLSLD_ADDR";
case PPCISD::ADDI_TLSLD_L_ADDR: return "PPCISD::ADDI_TLSLD_L_ADDR";
case PPCISD::ADDIS_DTPREL_HA: return "PPCISD::ADDIS_DTPREL_HA";
case PPCISD::ADDI_DTPREL_L: return "PPCISD::ADDI_DTPREL_L";
case PPCISD::PADDI_DTPREL:
return "PPCISD::PADDI_DTPREL";
case PPCISD::VADD_SPLAT: return "PPCISD::VADD_SPLAT";
case PPCISD::SC: return "PPCISD::SC";
case PPCISD::CLRBHRB: return "PPCISD::CLRBHRB";
case PPCISD::MFBHRBE: return "PPCISD::MFBHRBE";
case PPCISD::RFEBB: return "PPCISD::RFEBB";
case PPCISD::XXSWAPD: return "PPCISD::XXSWAPD";
case PPCISD::SWAP_NO_CHAIN: return "PPCISD::SWAP_NO_CHAIN";
case PPCISD::VABSD: return "PPCISD::VABSD";
case PPCISD::BUILD_FP128: return "PPCISD::BUILD_FP128";
case PPCISD::BUILD_SPE64: return "PPCISD::BUILD_SPE64";
case PPCISD::EXTRACT_SPE: return "PPCISD::EXTRACT_SPE";
case PPCISD::EXTSWSLI: return "PPCISD::EXTSWSLI";
case PPCISD::LD_VSX_LH: return "PPCISD::LD_VSX_LH";
case PPCISD::FP_EXTEND_HALF: return "PPCISD::FP_EXTEND_HALF";
case PPCISD::MAT_PCREL_ADDR: return "PPCISD::MAT_PCREL_ADDR";
case PPCISD::TLS_DYNAMIC_MAT_PCREL_ADDR:
return "PPCISD::TLS_DYNAMIC_MAT_PCREL_ADDR";
case PPCISD::TLS_LOCAL_EXEC_MAT_ADDR:
return "PPCISD::TLS_LOCAL_EXEC_MAT_ADDR";
case PPCISD::ACC_BUILD: return "PPCISD::ACC_BUILD";
case PPCISD::PAIR_BUILD: return "PPCISD::PAIR_BUILD";
case PPCISD::EXTRACT_VSX_REG: return "PPCISD::EXTRACT_VSX_REG";
case PPCISD::XXMFACC: return "PPCISD::XXMFACC";
case PPCISD::LD_SPLAT: return "PPCISD::LD_SPLAT";
case PPCISD::ZEXT_LD_SPLAT: return "PPCISD::ZEXT_LD_SPLAT";
case PPCISD::SEXT_LD_SPLAT: return "PPCISD::SEXT_LD_SPLAT";
case PPCISD::FNMSUB: return "PPCISD::FNMSUB";
case PPCISD::STRICT_FADDRTZ:
return "PPCISD::STRICT_FADDRTZ";
case PPCISD::STRICT_FCTIDZ:
return "PPCISD::STRICT_FCTIDZ";
case PPCISD::STRICT_FCTIWZ:
return "PPCISD::STRICT_FCTIWZ";
case PPCISD::STRICT_FCTIDUZ:
return "PPCISD::STRICT_FCTIDUZ";
case PPCISD::STRICT_FCTIWUZ:
return "PPCISD::STRICT_FCTIWUZ";
case PPCISD::STRICT_FCFID:
return "PPCISD::STRICT_FCFID";
case PPCISD::STRICT_FCFIDU:
return "PPCISD::STRICT_FCFIDU";
case PPCISD::STRICT_FCFIDS:
return "PPCISD::STRICT_FCFIDS";
case PPCISD::STRICT_FCFIDUS:
return "PPCISD::STRICT_FCFIDUS";
case PPCISD::LXVRZX: return "PPCISD::LXVRZX";
}
return nullptr;
}
EVT PPCTargetLowering::getSetCCResultType(const DataLayout &DL, LLVMContext &C,
EVT VT) const {
if (!VT.isVector())
return Subtarget.useCRBits() ? MVT::i1 : MVT::i32;
return VT.changeVectorElementTypeToInteger();
}
bool PPCTargetLowering::enableAggressiveFMAFusion(EVT VT) const {
assert(VT.isFloatingPoint() && "Non-floating-point FMA?");
return true;
}
//===----------------------------------------------------------------------===//
// Node matching predicates, for use by the tblgen matching code.
//===----------------------------------------------------------------------===//
/// isFloatingPointZero - Return true if this is 0.0 or -0.0.
static bool isFloatingPointZero(SDValue Op) {
if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(Op))
return CFP->getValueAPF().isZero();
else if (ISD::isEXTLoad(Op.getNode()) || ISD::isNON_EXTLoad(Op.getNode())) {
// Maybe this has already been legalized into the constant pool?
if (ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(Op.getOperand(1)))
if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CP->getConstVal()))
return CFP->getValueAPF().isZero();
}
return false;
}
/// isConstantOrUndef - Op is either an undef node or a ConstantSDNode. Return
/// true if Op is undef or if it matches the specified value.
static bool isConstantOrUndef(int Op, int Val) {
return Op < 0 || Op == Val;
}
/// isVPKUHUMShuffleMask - Return true if this is the shuffle mask for a
/// VPKUHUM instruction.
/// The ShuffleKind distinguishes between big-endian operations with
/// two different inputs (0), either-endian operations with two identical
/// inputs (1), and little-endian operations with two different inputs (2).
/// For the latter, the input operands are swapped (see PPCInstrAltivec.td).
bool PPC::isVPKUHUMShuffleMask(ShuffleVectorSDNode *N, unsigned ShuffleKind,
SelectionDAG &DAG) {
bool IsLE = DAG.getDataLayout().isLittleEndian();
if (ShuffleKind == 0) {
if (IsLE)
return false;
for (unsigned i = 0; i != 16; ++i)
if (!isConstantOrUndef(N->getMaskElt(i), i*2+1))
return false;
} else if (ShuffleKind == 2) {
if (!IsLE)
return false;
for (unsigned i = 0; i != 16; ++i)
if (!isConstantOrUndef(N->getMaskElt(i), i*2))
return false;
} else if (ShuffleKind == 1) {
unsigned j = IsLE ? 0 : 1;
for (unsigned i = 0; i != 8; ++i)
if (!isConstantOrUndef(N->getMaskElt(i), i*2+j) ||
!isConstantOrUndef(N->getMaskElt(i+8), i*2+j))
return false;
}
return true;
}
/// isVPKUWUMShuffleMask - Return true if this is the shuffle mask for a
/// VPKUWUM instruction.
/// The ShuffleKind distinguishes between big-endian operations with
/// two different inputs (0), either-endian operations with two identical
/// inputs (1), and little-endian operations with two different inputs (2).
/// For the latter, the input operands are swapped (see PPCInstrAltivec.td).
bool PPC::isVPKUWUMShuffleMask(ShuffleVectorSDNode *N, unsigned ShuffleKind,
SelectionDAG &DAG) {
bool IsLE = DAG.getDataLayout().isLittleEndian();
if (ShuffleKind == 0) {
if (IsLE)
return false;
for (unsigned i = 0; i != 16; i += 2)
if (!isConstantOrUndef(N->getMaskElt(i ), i*2+2) ||
!isConstantOrUndef(N->getMaskElt(i+1), i*2+3))
return false;
} else if (ShuffleKind == 2) {
if (!IsLE)
return false;
for (unsigned i = 0; i != 16; i += 2)
if (!isConstantOrUndef(N->getMaskElt(i ), i*2) ||
!isConstantOrUndef(N->getMaskElt(i+1), i*2+1))
return false;
} else if (ShuffleKind == 1) {
unsigned j = IsLE ? 0 : 2;
for (unsigned i = 0; i != 8; i += 2)
if (!isConstantOrUndef(N->getMaskElt(i ), i*2+j) ||
!isConstantOrUndef(N->getMaskElt(i+1), i*2+j+1) ||
!isConstantOrUndef(N->getMaskElt(i+8), i*2+j) ||
!isConstantOrUndef(N->getMaskElt(i+9), i*2+j+1))
return false;
}
return true;
}
/// isVPKUDUMShuffleMask - Return true if this is the shuffle mask for a
/// VPKUDUM instruction, AND the VPKUDUM instruction exists for the
/// current subtarget.
///
/// The ShuffleKind distinguishes between big-endian operations with
/// two different inputs (0), either-endian operations with two identical
/// inputs (1), and little-endian operations with two different inputs (2).
/// For the latter, the input operands are swapped (see PPCInstrAltivec.td).
bool PPC::isVPKUDUMShuffleMask(ShuffleVectorSDNode *N, unsigned ShuffleKind,
SelectionDAG &DAG) {
const PPCSubtarget& Subtarget =
static_cast<const PPCSubtarget&>(DAG.getSubtarget());
if (!Subtarget.hasP8Vector())
return false;
bool IsLE = DAG.getDataLayout().isLittleEndian();
if (ShuffleKind == 0) {
if (IsLE)
return false;
for (unsigned i = 0; i != 16; i += 4)
if (!isConstantOrUndef(N->getMaskElt(i ), i*2+4) ||
!isConstantOrUndef(N->getMaskElt(i+1), i*2+5) ||
!isConstantOrUndef(N->getMaskElt(i+2), i*2+6) ||
!isConstantOrUndef(N->getMaskElt(i+3), i*2+7))
return false;
} else if (ShuffleKind == 2) {
if (!IsLE)
return false;
for (unsigned i = 0; i != 16; i += 4)
if (!isConstantOrUndef(N->getMaskElt(i ), i*2) ||
!isConstantOrUndef(N->getMaskElt(i+1), i*2+1) ||
!isConstantOrUndef(N->getMaskElt(i+2), i*2+2) ||
!isConstantOrUndef(N->getMaskElt(i+3), i*2+3))
return false;
} else if (ShuffleKind == 1) {
unsigned j = IsLE ? 0 : 4;
for (unsigned i = 0; i != 8; i += 4)
if (!isConstantOrUndef(N->getMaskElt(i ), i*2+j) ||
!isConstantOrUndef(N->getMaskElt(i+1), i*2+j+1) ||
!isConstantOrUndef(N->getMaskElt(i+2), i*2+j+2) ||
!isConstantOrUndef(N->getMaskElt(i+3), i*2+j+3) ||
!isConstantOrUndef(N->getMaskElt(i+8), i*2+j) ||
!isConstantOrUndef(N->getMaskElt(i+9), i*2+j+1) ||
!isConstantOrUndef(N->getMaskElt(i+10), i*2+j+2) ||
!isConstantOrUndef(N->getMaskElt(i+11), i*2+j+3))
return false;
}
return true;
}
/// isVMerge - Common function, used to match vmrg* shuffles.
///
static bool isVMerge(ShuffleVectorSDNode *N, unsigned UnitSize,
unsigned LHSStart, unsigned RHSStart) {
if (N->getValueType(0) != MVT::v16i8)
return false;
assert((UnitSize == 1 || UnitSize == 2 || UnitSize == 4) &&
"Unsupported merge size!");
for (unsigned i = 0; i != 8/UnitSize; ++i) // Step over units
for (unsigned j = 0; j != UnitSize; ++j) { // Step over bytes within unit
if (!isConstantOrUndef(N->getMaskElt(i*UnitSize*2+j),
LHSStart+j+i*UnitSize) ||
!isConstantOrUndef(N->getMaskElt(i*UnitSize*2+UnitSize+j),
RHSStart+j+i*UnitSize))
return false;
}
return true;
}
/// isVMRGLShuffleMask - Return true if this is a shuffle mask suitable for
/// a VMRGL* instruction with the specified unit size (1,2 or 4 bytes).
/// The ShuffleKind distinguishes between big-endian merges with two
/// different inputs (0), either-endian merges with two identical inputs (1),
/// and little-endian merges with two different inputs (2). For the latter,
/// the input operands are swapped (see PPCInstrAltivec.td).
bool PPC::isVMRGLShuffleMask(ShuffleVectorSDNode *N, unsigned UnitSize,
unsigned ShuffleKind, SelectionDAG &DAG) {
if (DAG.getDataLayout().isLittleEndian()) {
if (ShuffleKind == 1) // unary
return isVMerge(N, UnitSize, 0, 0);
else if (ShuffleKind == 2) // swapped
return isVMerge(N, UnitSize, 0, 16);
else
return false;
} else {
if (ShuffleKind == 1) // unary
return isVMerge(N, UnitSize, 8, 8);
else if (ShuffleKind == 0) // normal
return isVMerge(N, UnitSize, 8, 24);
else
return false;
}
}
/// isVMRGHShuffleMask - Return true if this is a shuffle mask suitable for
/// a VMRGH* instruction with the specified unit size (1,2 or 4 bytes).
/// The ShuffleKind distinguishes between big-endian merges with two
/// different inputs (0), either-endian merges with two identical inputs (1),
/// and little-endian merges with two different inputs (2). For the latter,
/// the input operands are swapped (see PPCInstrAltivec.td).
bool PPC::isVMRGHShuffleMask(ShuffleVectorSDNode *N, unsigned UnitSize,
unsigned ShuffleKind, SelectionDAG &DAG) {
if (DAG.getDataLayout().isLittleEndian()) {
if (ShuffleKind == 1) // unary
return isVMerge(N, UnitSize, 8, 8);
else if (ShuffleKind == 2) // swapped
return isVMerge(N, UnitSize, 8, 24);
else
return false;
} else {
if (ShuffleKind == 1) // unary
return isVMerge(N, UnitSize, 0, 0);
else if (ShuffleKind == 0) // normal
return isVMerge(N, UnitSize, 0, 16);
else
return false;
}
}
/**
* Common function used to match vmrgew and vmrgow shuffles
*
* The indexOffset determines whether to look for even or odd words in
* the shuffle mask. This is based on the of the endianness of the target
* machine.
* - Little Endian:
* - Use offset of 0 to check for odd elements
* - Use offset of 4 to check for even elements
* - Big Endian:
* - Use offset of 0 to check for even elements
* - Use offset of 4 to check for odd elements
* A detailed description of the vector element ordering for little endian and
* big endian can be found at
* http://www.ibm.com/developerworks/library/l-ibm-xl-c-cpp-compiler/index.html
* Targeting your applications - what little endian and big endian IBM XL C/C++
* compiler differences mean to you
*
* The mask to the shuffle vector instruction specifies the indices of the
* elements from the two input vectors to place in the result. The elements are
* numbered in array-access order, starting with the first vector. These vectors
* are always of type v16i8, thus each vector will contain 16 elements of size
* 8. More info on the shuffle vector can be found in the
* http://llvm.org/docs/LangRef.html#shufflevector-instruction
* Language Reference.
*
* The RHSStartValue indicates whether the same input vectors are used (unary)
* or two different input vectors are used, based on the following:
* - If the instruction uses the same vector for both inputs, the range of the
* indices will be 0 to 15. In this case, the RHSStart value passed should
* be 0.
* - If the instruction has two different vectors then the range of the
* indices will be 0 to 31. In this case, the RHSStart value passed should
* be 16 (indices 0-15 specify elements in the first vector while indices 16
* to 31 specify elements in the second vector).
*
* \param[in] N The shuffle vector SD Node to analyze
* \param[in] IndexOffset Specifies whether to look for even or odd elements
* \param[in] RHSStartValue Specifies the starting index for the righthand input
* vector to the shuffle_vector instruction
* \return true iff this shuffle vector represents an even or odd word merge
*/
static bool isVMerge(ShuffleVectorSDNode *N, unsigned IndexOffset,
unsigned RHSStartValue) {
if (N->getValueType(0) != MVT::v16i8)
return false;
for (unsigned i = 0; i < 2; ++i)
for (unsigned j = 0; j < 4; ++j)
if (!isConstantOrUndef(N->getMaskElt(i*4+j),
i*RHSStartValue+j+IndexOffset) ||
!isConstantOrUndef(N->getMaskElt(i*4+j+8),
i*RHSStartValue+j+IndexOffset+8))
return false;
return true;
}
/**
* Determine if the specified shuffle mask is suitable for the vmrgew or
* vmrgow instructions.
*
* \param[in] N The shuffle vector SD Node to analyze
* \param[in] CheckEven Check for an even merge (true) or an odd merge (false)
* \param[in] ShuffleKind Identify the type of merge:
* - 0 = big-endian merge with two different inputs;
* - 1 = either-endian merge with two identical inputs;
* - 2 = little-endian merge with two different inputs (inputs are swapped for
* little-endian merges).
* \param[in] DAG The current SelectionDAG
* \return true iff this shuffle mask
*/
bool PPC::isVMRGEOShuffleMask(ShuffleVectorSDNode *N, bool CheckEven,
unsigned ShuffleKind, SelectionDAG &DAG) {
if (DAG.getDataLayout().isLittleEndian()) {
unsigned indexOffset = CheckEven ? 4 : 0;
if (ShuffleKind == 1) // Unary
return isVMerge(N, indexOffset, 0);
else if (ShuffleKind == 2) // swapped
return isVMerge(N, indexOffset, 16);
else
return false;
}
else {
unsigned indexOffset = CheckEven ? 0 : 4;
if (ShuffleKind == 1) // Unary
return isVMerge(N, indexOffset, 0);
else if (ShuffleKind == 0) // Normal
return isVMerge(N, indexOffset, 16);
else
return false;
}
return false;
}
/// isVSLDOIShuffleMask - If this is a vsldoi shuffle mask, return the shift
/// amount, otherwise return -1.
/// The ShuffleKind distinguishes between big-endian operations with two
/// different inputs (0), either-endian operations with two identical inputs
/// (1), and little-endian operations with two different inputs (2). For the
/// latter, the input operands are swapped (see PPCInstrAltivec.td).
int PPC::isVSLDOIShuffleMask(SDNode *N, unsigned ShuffleKind,
SelectionDAG &DAG) {
if (N->getValueType(0) != MVT::v16i8)
return -1;
ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
// Find the first non-undef value in the shuffle mask.
unsigned i;
for (i = 0; i != 16 && SVOp->getMaskElt(i) < 0; ++i)
/*search*/;
if (i == 16) return -1; // all undef.
// Otherwise, check to see if the rest of the elements are consecutively
// numbered from this value.
unsigned ShiftAmt = SVOp->getMaskElt(i);
if (ShiftAmt < i) return -1;
ShiftAmt -= i;
bool isLE = DAG.getDataLayout().isLittleEndian();
if ((ShuffleKind == 0 && !isLE) || (ShuffleKind == 2 && isLE)) {
// Check the rest of the elements to see if they are consecutive.
for (++i; i != 16; ++i)
if (!isConstantOrUndef(SVOp->getMaskElt(i), ShiftAmt+i))
return -1;
} else if (ShuffleKind == 1) {
// Check the rest of the elements to see if they are consecutive.
for (++i; i != 16; ++i)
if (!isConstantOrUndef(SVOp->getMaskElt(i), (ShiftAmt+i) & 15))
return -1;
} else
return -1;
if (isLE)
ShiftAmt = 16 - ShiftAmt;
return ShiftAmt;
}
/// isSplatShuffleMask - Return true if the specified VECTOR_SHUFFLE operand
/// specifies a splat of a single element that is suitable for input to
/// one of the splat operations (VSPLTB/VSPLTH/VSPLTW/XXSPLTW/LXVDSX/etc.).
bool PPC::isSplatShuffleMask(ShuffleVectorSDNode *N, unsigned EltSize) {
assert(N->getValueType(0) == MVT::v16i8 && isPowerOf2_32(EltSize) &&
EltSize <= 8 && "Can only handle 1,2,4,8 byte element sizes");
// The consecutive indices need to specify an element, not part of two
// different elements. So abandon ship early if this isn't the case.
if (N->getMaskElt(0) % EltSize != 0)
return false;
// This is a splat operation if each element of the permute is the same, and
// if the value doesn't reference the second vector.
unsigned ElementBase = N->getMaskElt(0);
// FIXME: Handle UNDEF elements too!
if (ElementBase >= 16)
return false;
// Check that the indices are consecutive, in the case of a multi-byte element
// splatted with a v16i8 mask.
for (unsigned i = 1; i != EltSize; ++i)
if (N->getMaskElt(i) < 0 || N->getMaskElt(i) != (int)(i+ElementBase))
return false;
for (unsigned i = EltSize, e = 16; i != e; i += EltSize) {
if (N->getMaskElt(i) < 0) continue;
for (unsigned j = 0; j != EltSize; ++j)
if (N->getMaskElt(i+j) != N->getMaskElt(j))
return false;
}
return true;
}
/// Check that the mask is shuffling N byte elements. Within each N byte
/// element of the mask, the indices could be either in increasing or
/// decreasing order as long as they are consecutive.
/// \param[in] N the shuffle vector SD Node to analyze
/// \param[in] Width the element width in bytes, could be 2/4/8/16 (HalfWord/
/// Word/DoubleWord/QuadWord).
/// \param[in] StepLen the delta indices number among the N byte element, if
/// the mask is in increasing/decreasing order then it is 1/-1.
/// \return true iff the mask is shuffling N byte elements.
static bool isNByteElemShuffleMask(ShuffleVectorSDNode *N, unsigned Width,
int StepLen) {
assert((Width == 2 || Width == 4 || Width == 8 || Width == 16) &&
"Unexpected element width.");
assert((StepLen == 1 || StepLen == -1) && "Unexpected element width.");
unsigned NumOfElem = 16 / Width;
unsigned MaskVal[16]; // Width is never greater than 16
for (unsigned i = 0; i < NumOfElem; ++i) {
MaskVal[0] = N->getMaskElt(i * Width);
if ((StepLen == 1) && (MaskVal[0] % Width)) {
return false;
} else if ((StepLen == -1) && ((MaskVal[0] + 1) % Width)) {
return false;
}
for (unsigned int j = 1; j < Width; ++j) {
MaskVal[j] = N->getMaskElt(i * Width + j);
if (MaskVal[j] != MaskVal[j-1] + StepLen) {
return false;
}
}
}
return true;
}
bool PPC::isXXINSERTWMask(ShuffleVectorSDNode *N, unsigned &ShiftElts,
unsigned &InsertAtByte, bool &Swap, bool IsLE) {
if (!isNByteElemShuffleMask(N, 4, 1))
return false;
// Now we look at mask elements 0,4,8,12
unsigned M0 = N->getMaskElt(0) / 4;
unsigned M1 = N->getMaskElt(4) / 4;
unsigned M2 = N->getMaskElt(8) / 4;
unsigned M3 = N->getMaskElt(12) / 4;
unsigned LittleEndianShifts[] = { 2, 1, 0, 3 };
unsigned BigEndianShifts[] = { 3, 0, 1, 2 };
// Below, let H and L be arbitrary elements of the shuffle mask
// where H is in the range [4,7] and L is in the range [0,3].
// H, 1, 2, 3 or L, 5, 6, 7
if ((M0 > 3 && M1 == 1 && M2 == 2 && M3 == 3) ||
(M0 < 4 && M1 == 5 && M2 == 6 && M3 == 7)) {
ShiftElts = IsLE ? LittleEndianShifts[M0 & 0x3] : BigEndianShifts[M0 & 0x3];
InsertAtByte = IsLE ? 12 : 0;
Swap = M0 < 4;
return true;
}
// 0, H, 2, 3 or 4, L, 6, 7
if ((M1 > 3 && M0 == 0 && M2 == 2 && M3 == 3) ||
(M1 < 4 && M0 == 4 && M2 == 6 && M3 == 7)) {
ShiftElts = IsLE ? LittleEndianShifts[M1 & 0x3] : BigEndianShifts[M1 & 0x3];
InsertAtByte = IsLE ? 8 : 4;
Swap = M1 < 4;
return true;
}
// 0, 1, H, 3 or 4, 5, L, 7
if ((M2 > 3 && M0 == 0 && M1 == 1 && M3 == 3) ||
(M2 < 4 && M0 == 4 && M1 == 5 && M3 == 7)) {
ShiftElts = IsLE ? LittleEndianShifts[M2 & 0x3] : BigEndianShifts[M2 & 0x3];
InsertAtByte = IsLE ? 4 : 8;
Swap = M2 < 4;
return true;
}
// 0, 1, 2, H or 4, 5, 6, L
if ((M3 > 3 && M0 == 0 && M1 == 1 && M2 == 2) ||
(M3 < 4 && M0 == 4 && M1 == 5 && M2 == 6)) {
ShiftElts = IsLE ? LittleEndianShifts[M3 & 0x3] : BigEndianShifts[M3 & 0x3];
InsertAtByte = IsLE ? 0 : 12;
Swap = M3 < 4;
return true;
}
// If both vector operands for the shuffle are the same vector, the mask will
// contain only elements from the first one and the second one will be undef.
if (N->getOperand(1).isUndef()) {
ShiftElts = 0;
Swap = true;
unsigned XXINSERTWSrcElem = IsLE ? 2 : 1;
if (M0 == XXINSERTWSrcElem && M1 == 1 && M2 == 2 && M3 == 3) {
InsertAtByte = IsLE ? 12 : 0;
return true;
}
if (M0 == 0 && M1 == XXINSERTWSrcElem && M2 == 2 && M3 == 3) {
InsertAtByte = IsLE ? 8 : 4;
return true;
}
if (M0 == 0 && M1 == 1 && M2 == XXINSERTWSrcElem && M3 == 3) {
InsertAtByte = IsLE ? 4 : 8;
return true;
}
if (M0 == 0 && M1 == 1 && M2 == 2 && M3 == XXINSERTWSrcElem) {
InsertAtByte = IsLE ? 0 : 12;
return true;
}
}
return false;
}
bool PPC::isXXSLDWIShuffleMask(ShuffleVectorSDNode *N, unsigned &ShiftElts,
bool &Swap, bool IsLE) {
assert(N->getValueType(0) == MVT::v16i8 && "Shuffle vector expects v16i8");
// Ensure each byte index of the word is consecutive.
if (!isNByteElemShuffleMask(N, 4, 1))
return false;
// Now we look at mask elements 0,4,8,12, which are the beginning of words.
unsigned M0 = N->getMaskElt(0) / 4;
unsigned M1 = N->getMaskElt(4) / 4;
unsigned M2 = N->getMaskElt(8) / 4;
unsigned M3 = N->getMaskElt(12) / 4;
// If both vector operands for the shuffle are the same vector, the mask will
// contain only elements from the first one and the second one will be undef.
if (N->getOperand(1).isUndef()) {
assert(M0 < 4 && "Indexing into an undef vector?");
if (M1 != (M0 + 1) % 4 || M2 != (M1 + 1) % 4 || M3 != (M2 + 1) % 4)
return false;
ShiftElts = IsLE ? (4 - M0) % 4 : M0;
Swap = false;
return true;
}
// Ensure each word index of the ShuffleVector Mask is consecutive.
if (M1 != (M0 + 1) % 8 || M2 != (M1 + 1) % 8 || M3 != (M2 + 1) % 8)
return false;
if (IsLE) {
if (M0 == 0 || M0 == 7 || M0 == 6 || M0 == 5) {
// Input vectors don't need to be swapped if the leading element
// of the result is one of the 3 left elements of the second vector
// (or if there is no shift to be done at all).
Swap = false;
ShiftElts = (8 - M0) % 8;
} else if (M0 == 4 || M0 == 3 || M0 == 2 || M0 == 1) {
// Input vectors need to be swapped if the leading element
// of the result is one of the 3 left elements of the first vector
// (or if we're shifting by 4 - thereby simply swapping the vectors).
Swap = true;
ShiftElts = (4 - M0) % 4;
}
return true;
} else { // BE
if (M0 == 0 || M0 == 1 || M0 == 2 || M0 == 3) {
// Input vectors don't need to be swapped if the leading element
// of the result is one of the 4 elements of the first vector.
Swap = false;
ShiftElts = M0;
} else if (M0 == 4 || M0 == 5 || M0 == 6 || M0 == 7) {
// Input vectors need to be swapped if the leading element
// of the result is one of the 4 elements of the right vector.
Swap = true;
ShiftElts = M0 - 4;
}
return true;
}
}
bool static isXXBRShuffleMaskHelper(ShuffleVectorSDNode *N, int Width) {
assert(N->getValueType(0) == MVT::v16i8 && "Shuffle vector expects v16i8");
if (!isNByteElemShuffleMask(N, Width, -1))
return false;
for (int i = 0; i < 16; i += Width)
if (N->getMaskElt(i) != i + Width - 1)
return false;
return true;
}
bool PPC::isXXBRHShuffleMask(ShuffleVectorSDNode *N) {
return isXXBRShuffleMaskHelper(N, 2);
}
bool PPC::isXXBRWShuffleMask(ShuffleVectorSDNode *N) {
return isXXBRShuffleMaskHelper(N, 4);
}
bool PPC::isXXBRDShuffleMask(ShuffleVectorSDNode *N) {
return isXXBRShuffleMaskHelper(N, 8);
}
bool PPC::isXXBRQShuffleMask(ShuffleVectorSDNode *N) {
return isXXBRShuffleMaskHelper(N, 16);
}
/// Can node \p N be lowered to an XXPERMDI instruction? If so, set \p Swap
/// if the inputs to the instruction should be swapped and set \p DM to the
/// value for the immediate.
/// Specifically, set \p Swap to true only if \p N can be lowered to XXPERMDI
/// AND element 0 of the result comes from the first input (LE) or second input
/// (BE). Set \p DM to the calculated result (0-3) only if \p N can be lowered.
/// \return true iff the given mask of shuffle node \p N is a XXPERMDI shuffle
/// mask.
bool PPC::isXXPERMDIShuffleMask(ShuffleVectorSDNode *N, unsigned &DM,
bool &Swap, bool IsLE) {
assert(N->getValueType(0) == MVT::v16i8 && "Shuffle vector expects v16i8");
// Ensure each byte index of the double word is consecutive.
if (!isNByteElemShuffleMask(N, 8, 1))
return false;
unsigned M0 = N->getMaskElt(0) / 8;
unsigned M1 = N->getMaskElt(8) / 8;
assert(((M0 | M1) < 4) && "A mask element out of bounds?");
// If both vector operands for the shuffle are the same vector, the mask will
// contain only elements from the first one and the second one will be undef.
if (N->getOperand(1).isUndef()) {
if ((M0 | M1) < 2) {
DM = IsLE ? (((~M1) & 1) << 1) + ((~M0) & 1) : (M0 << 1) + (M1 & 1);
Swap = false;
return true;
} else
return false;
}
if (IsLE) {
if (M0 > 1 && M1 < 2) {
Swap = false;
} else if (M0 < 2 && M1 > 1) {
M0 = (M0 + 2) % 4;
M1 = (M1 + 2) % 4;
Swap = true;
} else
return false;
// Note: if control flow comes here that means Swap is already set above
DM = (((~M1) & 1) << 1) + ((~M0) & 1);
return true;
} else { // BE
if (M0 < 2 && M1 > 1) {
Swap = false;
} else if (M0 > 1 && M1 < 2) {
M0 = (M0 + 2) % 4;
M1 = (M1 + 2) % 4;
Swap = true;
} else
return false;
// Note: if control flow comes here that means Swap is already set above
DM = (M0 << 1) + (M1 & 1);
return true;
}
}
/// getSplatIdxForPPCMnemonics - Return the splat index as a value that is
/// appropriate for PPC mnemonics (which have a big endian bias - namely
/// elements are counted from the left of the vector register).
unsigned PPC::getSplatIdxForPPCMnemonics(SDNode *N, unsigned EltSize,
SelectionDAG &DAG) {
ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
assert(isSplatShuffleMask(SVOp, EltSize));
if (DAG.getDataLayout().isLittleEndian())
return (16 / EltSize) - 1 - (SVOp->getMaskElt(0) / EltSize);
else
return SVOp->getMaskElt(0) / EltSize;
}
/// get_VSPLTI_elt - If this is a build_vector of constants which can be formed
/// by using a vspltis[bhw] instruction of the specified element size, return
/// the constant being splatted. The ByteSize field indicates the number of
/// bytes of each element [124] -> [bhw].
SDValue PPC::get_VSPLTI_elt(SDNode *N, unsigned ByteSize, SelectionDAG &DAG) {
SDValue OpVal;
// If ByteSize of the splat is bigger than the element size of the
// build_vector, then we have a case where we are checking for a splat where
// multiple elements of the buildvector are folded together into a single
// logical element of the splat (e.g. "vsplish 1" to splat {0,1}*8).
unsigned EltSize = 16/N->getNumOperands();
if (EltSize < ByteSize) {
unsigned Multiple = ByteSize/EltSize; // Number of BV entries per spltval.
SDValue UniquedVals[4];
assert(Multiple > 1 && Multiple <= 4 && "How can this happen?");
// See if all of the elements in the buildvector agree across.
for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
if (N->getOperand(i).isUndef()) continue;
// If the element isn't a constant, bail fully out.
if (!isa<ConstantSDNode>(N->getOperand(i))) return SDValue();
if (!UniquedVals[i&(Multiple-1)].getNode())
UniquedVals[i&(Multiple-1)] = N->getOperand(i);
else if (UniquedVals[i&(Multiple-1)] != N->getOperand(i))
return SDValue(); // no match.
}
// Okay, if we reached this point, UniquedVals[0..Multiple-1] contains
// either constant or undef values that are identical for each chunk. See
// if these chunks can form into a larger vspltis*.
// Check to see if all of the leading entries are either 0 or -1. If
// neither, then this won't fit into the immediate field.
bool LeadingZero = true;
bool LeadingOnes = true;
for (unsigned i = 0; i != Multiple-1; ++i) {
if (!UniquedVals[i].getNode()) continue; // Must have been undefs.
LeadingZero &= isNullConstant(UniquedVals[i]);
LeadingOnes &= isAllOnesConstant(UniquedVals[i]);
}
// Finally, check the least significant entry.
if (LeadingZero) {
if (!UniquedVals[Multiple-1].getNode())
return DAG.getTargetConstant(0, SDLoc(N), MVT::i32); // 0,0,0,undef
int Val = cast<ConstantSDNode>(UniquedVals[Multiple-1])->getZExtValue();
if (Val < 16) // 0,0,0,4 -> vspltisw(4)
return DAG.getTargetConstant(Val, SDLoc(N), MVT::i32);
}
if (LeadingOnes) {
if (!UniquedVals[Multiple-1].getNode())
return DAG.getTargetConstant(~0U, SDLoc(N), MVT::i32); // -1,-1,-1,undef
int Val =cast<ConstantSDNode>(UniquedVals[Multiple-1])->getSExtValue();
if (Val >= -16) // -1,-1,-1,-2 -> vspltisw(-2)
return DAG.getTargetConstant(Val, SDLoc(N), MVT::i32);
}
return SDValue();
}
// Check to see if this buildvec has a single non-undef value in its elements.
for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
if (N->getOperand(i).isUndef()) continue;
if (!OpVal.getNode())
OpVal = N->getOperand(i);
else if (OpVal != N->getOperand(i))
return SDValue();
}
if (!OpVal.getNode()) return SDValue(); // All UNDEF: use implicit def.
unsigned ValSizeInBytes = EltSize;
uint64_t Value = 0;
if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(OpVal)) {
Value = CN->getZExtValue();
} else if (ConstantFPSDNode *CN = dyn_cast<ConstantFPSDNode>(OpVal)) {
assert(CN->getValueType(0) == MVT::f32 && "Only one legal FP vector type!");
Value = FloatToBits(CN->getValueAPF().convertToFloat());
}
// If the splat value is larger than the element value, then we can never do
// this splat. The only case that we could fit the replicated bits into our
// immediate field for would be zero, and we prefer to use vxor for it.
if (ValSizeInBytes < ByteSize) return SDValue();
// If the element value is larger than the splat value, check if it consists
// of a repeated bit pattern of size ByteSize.
if (!APInt(ValSizeInBytes * 8, Value).isSplat(ByteSize * 8))
return SDValue();
// Properly sign extend the value.
int MaskVal = SignExtend32(Value, ByteSize * 8);
// If this is zero, don't match, zero matches ISD::isBuildVectorAllZeros.
if (MaskVal == 0) return SDValue();
// Finally, if this value fits in a 5 bit sext field, return it
if (SignExtend32<5>(MaskVal) == MaskVal)
return DAG.getTargetConstant(MaskVal, SDLoc(N), MVT::i32);
return SDValue();
}
//===----------------------------------------------------------------------===//
// Addressing Mode Selection
//===----------------------------------------------------------------------===//
/// isIntS16Immediate - This method tests to see if the node is either a 32-bit
/// or 64-bit immediate, and if the value can be accurately represented as a
/// sign extension from a 16-bit value. If so, this returns true and the
/// immediate.
bool llvm::isIntS16Immediate(SDNode *N, int16_t &Imm) {
if (!isa<ConstantSDNode>(N))
return false;
Imm = (int16_t)cast<ConstantSDNode>(N)->getZExtValue();
if (N->getValueType(0) == MVT::i32)
return Imm == (int32_t)cast<ConstantSDNode>(N)->getZExtValue();
else
return Imm == (int64_t)cast<ConstantSDNode>(N)->getZExtValue();
}
bool llvm::isIntS16Immediate(SDValue Op, int16_t &Imm) {
return isIntS16Immediate(Op.getNode(), Imm);
}
/// Used when computing address flags for selecting loads and stores.
/// If we have an OR, check if the LHS and RHS are provably disjoint.
/// An OR of two provably disjoint values is equivalent to an ADD.
/// Most PPC load/store instructions compute the effective address as a sum,
/// so doing this conversion is useful.
static bool provablyDisjointOr(SelectionDAG &DAG, const SDValue &N) {
if (N.getOpcode() != ISD::OR)
return false;
KnownBits LHSKnown = DAG.computeKnownBits(N.getOperand(0));
if (!LHSKnown.Zero.getBoolValue())
return false;
KnownBits RHSKnown = DAG.computeKnownBits(N.getOperand(1));
return (~(LHSKnown.Zero | RHSKnown.Zero) == 0);
}
/// SelectAddressEVXRegReg - Given the specified address, check to see if it can
/// be represented as an indexed [r+r] operation.
bool PPCTargetLowering::SelectAddressEVXRegReg(SDValue N, SDValue &Base,
SDValue &Index,
SelectionDAG &DAG) const {
for (SDNode *U : N->uses()) {
if (MemSDNode *Memop = dyn_cast<MemSDNode>(U)) {
if (Memop->getMemoryVT() == MVT::f64) {
Base = N.getOperand(0);
Index = N.getOperand(1);
return true;
}
}
}
return false;
}
/// isIntS34Immediate - This method tests if value of node given can be
/// accurately represented as a sign extension from a 34-bit value. If so,
/// this returns true and the immediate.
bool llvm::isIntS34Immediate(SDNode *N, int64_t &Imm) {
if (!isa<ConstantSDNode>(N))
return false;
Imm = (int64_t)cast<ConstantSDNode>(N)->getZExtValue();
return isInt<34>(Imm);
}
bool llvm::isIntS34Immediate(SDValue Op, int64_t &Imm) {
return isIntS34Immediate(Op.getNode(), Imm);
}
/// SelectAddressRegReg - Given the specified addressed, check to see if it
/// can be represented as an indexed [r+r] operation. Returns false if it
/// can be more efficiently represented as [r+imm]. If \p EncodingAlignment is
/// non-zero and N can be represented by a base register plus a signed 16-bit
/// displacement, make a more precise judgement by checking (displacement % \p
/// EncodingAlignment).
bool PPCTargetLowering::SelectAddressRegReg(
SDValue N, SDValue &Base, SDValue &Index, SelectionDAG &DAG,
MaybeAlign EncodingAlignment) const {
// If we have a PC Relative target flag don't select as [reg+reg]. It will be
// a [pc+imm].
if (SelectAddressPCRel(N, Base))
return false;
int16_t Imm = 0;
if (N.getOpcode() == ISD::ADD) {
// Is there any SPE load/store (f64), which can't handle 16bit offset?
// SPE load/store can only handle 8-bit offsets.
if (hasSPE() && SelectAddressEVXRegReg(N, Base, Index, DAG))
return true;
if (isIntS16Immediate(N.getOperand(1), Imm) &&
(!EncodingAlignment || isAligned(*EncodingAlignment, Imm)))
return false; // r+i
if (N.getOperand(1).getOpcode() == PPCISD::Lo)
return false; // r+i
Base = N.getOperand(0);
Index = N.getOperand(1);
return true;
} else if (N.getOpcode() == ISD::OR) {
if (isIntS16Immediate(N.getOperand(1), Imm) &&
(!EncodingAlignment || isAligned(*EncodingAlignment, Imm)))
return false; // r+i can fold it if we can.
// If this is an or of disjoint bitfields, we can codegen this as an add
// (for better address arithmetic) if the LHS and RHS of the OR are provably
// disjoint.
KnownBits LHSKnown = DAG.computeKnownBits(N.getOperand(0));
if (LHSKnown.Zero.getBoolValue()) {
KnownBits RHSKnown = DAG.computeKnownBits(N.getOperand(1));
// If all of the bits are known zero on the LHS or RHS, the add won't
// carry.
if (~(LHSKnown.Zero | RHSKnown.Zero) == 0) {
Base = N.getOperand(0);
Index = N.getOperand(1);
return true;
}
}
}
return false;
}
// If we happen to be doing an i64 load or store into a stack slot that has
// less than a 4-byte alignment, then the frame-index elimination may need to
// use an indexed load or store instruction (because the offset may not be a
// multiple of 4). The extra register needed to hold the offset comes from the
// register scavenger, and it is possible that the scavenger will need to use
// an emergency spill slot. As a result, we need to make sure that a spill slot
// is allocated when doing an i64 load/store into a less-than-4-byte-aligned
// stack slot.
static void fixupFuncForFI(SelectionDAG &DAG, int FrameIdx, EVT VT) {
// FIXME: This does not handle the LWA case.
if (VT != MVT::i64)
return;
// NOTE: We'll exclude negative FIs here, which come from argument
// lowering, because there are no known test cases triggering this problem
// using packed structures (or similar). We can remove this exclusion if
// we find such a test case. The reason why this is so test-case driven is
// because this entire 'fixup' is only to prevent crashes (from the
// register scavenger) on not-really-valid inputs. For example, if we have:
// %a = alloca i1
// %b = bitcast i1* %a to i64*
// store i64* a, i64 b
// then the store should really be marked as 'align 1', but is not. If it
// were marked as 'align 1' then the indexed form would have been
// instruction-selected initially, and the problem this 'fixup' is preventing
// won't happen regardless.
if (FrameIdx < 0)
return;
MachineFunction &MF = DAG.getMachineFunction();
MachineFrameInfo &MFI = MF.getFrameInfo();
if (MFI.getObjectAlign(FrameIdx) >= Align(4))
return;
PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
FuncInfo->setHasNonRISpills();
}
/// Returns true if the address N can be represented by a base register plus
/// a signed 16-bit displacement [r+imm], and if it is not better
/// represented as reg+reg. If \p EncodingAlignment is non-zero, only accept
/// displacements that are multiples of that value.
bool PPCTargetLowering::SelectAddressRegImm(
SDValue N, SDValue &Disp, SDValue &Base, SelectionDAG &DAG,
MaybeAlign EncodingAlignment) const {
// FIXME dl should come from parent load or store, not from address
SDLoc dl(N);
// If we have a PC Relative target flag don't select as [reg+imm]. It will be
// a [pc+imm].
if (SelectAddressPCRel(N, Base))
return false;
// If this can be more profitably realized as r+r, fail.
if (SelectAddressRegReg(N, Disp, Base, DAG, EncodingAlignment))
return false;
if (N.getOpcode() == ISD::ADD) {
int16_t imm = 0;
if (isIntS16Immediate(N.getOperand(1), imm) &&
(!EncodingAlignment || isAligned(*EncodingAlignment, imm))) {
Disp = DAG.getTargetConstant(imm, dl, N.getValueType());
if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N.getOperand(0))) {
Base = DAG.getTargetFrameIndex(FI->getIndex(), N.getValueType());
fixupFuncForFI(DAG, FI->getIndex(), N.getValueType());
} else {
Base = N.getOperand(0);
}
return true; // [r+i]
} else if (N.getOperand(1).getOpcode() == PPCISD::Lo) {
// Match LOAD (ADD (X, Lo(G))).
assert(!cast<ConstantSDNode>(N.getOperand(1).getOperand(1))->getZExtValue()
&& "Cannot handle constant offsets yet!");
Disp = N.getOperand(1).getOperand(0); // The global address.
assert(Disp.getOpcode() == ISD::TargetGlobalAddress ||
Disp.getOpcode() == ISD::TargetGlobalTLSAddress ||
Disp.getOpcode() == ISD::TargetConstantPool ||
Disp.getOpcode() == ISD::TargetJumpTable);
Base = N.getOperand(0);
return true; // [&g+r]
}
} else if (N.getOpcode() == ISD::OR) {
int16_t imm = 0;
if (isIntS16Immediate(N.getOperand(1), imm) &&
(!EncodingAlignment || isAligned(*EncodingAlignment, imm))) {
// If this is an or of disjoint bitfields, we can codegen this as an add
// (for better address arithmetic) if the LHS and RHS of the OR are
// provably disjoint.
KnownBits LHSKnown = DAG.computeKnownBits(N.getOperand(0));
if ((LHSKnown.Zero.getZExtValue()|~(uint64_t)imm) == ~0ULL) {
// If all of the bits are known zero on the LHS or RHS, the add won't
// carry.
if (FrameIndexSDNode *FI =
dyn_cast<FrameIndexSDNode>(N.getOperand(0))) {
Base = DAG.getTargetFrameIndex(FI->getIndex(), N.getValueType());
fixupFuncForFI(DAG, FI->getIndex(), N.getValueType());
} else {
Base = N.getOperand(0);
}
Disp = DAG.getTargetConstant(imm, dl, N.getValueType());
return true;
}
}
} else if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) {
// Loading from a constant address.
// If this address fits entirely in a 16-bit sext immediate field, codegen
// this as "d, 0"
int16_t Imm;
if (isIntS16Immediate(CN, Imm) &&
(!EncodingAlignment || isAligned(*EncodingAlignment, Imm))) {
Disp = DAG.getTargetConstant(Imm, dl, CN->getValueType(0));
Base = DAG.getRegister(Subtarget.isPPC64() ? PPC::ZERO8 : PPC::ZERO,
CN->getValueType(0));
return true;
}
// Handle 32-bit sext immediates with LIS + addr mode.
if ((CN->getValueType(0) == MVT::i32 ||
(int64_t)CN->getZExtValue() == (int)CN->getZExtValue()) &&
(!EncodingAlignment ||
isAligned(*EncodingAlignment, CN->getZExtValue()))) {
int Addr = (int)CN->getZExtValue();
// Otherwise, break this down into an LIS + disp.
Disp = DAG.getTargetConstant((short)Addr, dl, MVT::i32);
Base = DAG.getTargetConstant((Addr - (signed short)Addr) >> 16, dl,
MVT::i32);
unsigned Opc = CN->getValueType(0) == MVT::i32 ? PPC::LIS : PPC::LIS8;
Base = SDValue(DAG.getMachineNode(Opc, dl, CN->getValueType(0), Base), 0);
return true;
}
}
Disp = DAG.getTargetConstant(0, dl, getPointerTy(DAG.getDataLayout()));
if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N)) {
Base = DAG.getTargetFrameIndex(FI->getIndex(), N.getValueType());
fixupFuncForFI(DAG, FI->getIndex(), N.getValueType());
} else
Base = N;
return true; // [r+0]
}
/// Similar to the 16-bit case but for instructions that take a 34-bit
/// displacement field (prefixed loads/stores).
bool PPCTargetLowering::SelectAddressRegImm34(SDValue N, SDValue &Disp,
SDValue &Base,
SelectionDAG &DAG) const {
// Only on 64-bit targets.
if (N.getValueType() != MVT::i64)
return false;
SDLoc dl(N);
int64_t Imm = 0;
if (N.getOpcode() == ISD::ADD) {
if (!isIntS34Immediate(N.getOperand(1), Imm))
return false;
Disp = DAG.getTargetConstant(Imm, dl, N.getValueType());
if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N.getOperand(0)))
Base = DAG.getTargetFrameIndex(FI->getIndex(), N.getValueType());
else
Base = N.getOperand(0);
return true;
}
if (N.getOpcode() == ISD::OR) {
if (!isIntS34Immediate(N.getOperand(1), Imm))
return false;
// If this is an or of disjoint bitfields, we can codegen this as an add
// (for better address arithmetic) if the LHS and RHS of the OR are
// provably disjoint.
KnownBits LHSKnown = DAG.computeKnownBits(N.getOperand(0));
if ((LHSKnown.Zero.getZExtValue() | ~(uint64_t)Imm) != ~0ULL)
return false;
if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N.getOperand(0)))
Base = DAG.getTargetFrameIndex(FI->getIndex(), N.getValueType());
else
Base = N.getOperand(0);
Disp = DAG.getTargetConstant(Imm, dl, N.getValueType());
return true;
}
if (isIntS34Immediate(N, Imm)) { // If the address is a 34-bit const.
Disp = DAG.getTargetConstant(Imm, dl, N.getValueType());
Base = DAG.getRegister(PPC::ZERO8, N.getValueType());
return true;
}
return false;
}
/// SelectAddressRegRegOnly - Given the specified addressed, force it to be
/// represented as an indexed [r+r] operation.
bool PPCTargetLowering::SelectAddressRegRegOnly(SDValue N, SDValue &Base,
SDValue &Index,
SelectionDAG &DAG) const {
// Check to see if we can easily represent this as an [r+r] address. This
// will fail if it thinks that the address is more profitably represented as
// reg+imm, e.g. where imm = 0.
if (SelectAddressRegReg(N, Base, Index, DAG))
return true;
// If the address is the result of an add, we will utilize the fact that the
// address calculation includes an implicit add. However, we can reduce
// register pressure if we do not materialize a constant just for use as the
// index register. We only get rid of the add if it is not an add of a
// value and a 16-bit signed constant and both have a single use.
int16_t imm = 0;
if (N.getOpcode() == ISD::ADD &&
(!isIntS16Immediate(N.getOperand(1), imm) ||
!N.getOperand(1).hasOneUse() || !N.getOperand(0).hasOneUse())) {
Base = N.getOperand(0);
Index = N.getOperand(1);
return true;
}
// Otherwise, do it the hard way, using R0 as the base register.
Base = DAG.getRegister(Subtarget.isPPC64() ? PPC::ZERO8 : PPC::ZERO,
N.getValueType());
Index = N;
return true;
}
template <typename Ty> static bool isValidPCRelNode(SDValue N) {
Ty *PCRelCand = dyn_cast<Ty>(N);
return PCRelCand && (PCRelCand->getTargetFlags() & PPCII::MO_PCREL_FLAG);
}
/// Returns true if this address is a PC Relative address.
/// PC Relative addresses are marked with the flag PPCII::MO_PCREL_FLAG
/// or if the node opcode is PPCISD::MAT_PCREL_ADDR.
bool PPCTargetLowering::SelectAddressPCRel(SDValue N, SDValue &Base) const {
// This is a materialize PC Relative node. Always select this as PC Relative.
Base = N;
if (N.getOpcode() == PPCISD::MAT_PCREL_ADDR)
return true;
if (isValidPCRelNode<ConstantPoolSDNode>(N) ||
isValidPCRelNode<GlobalAddressSDNode>(N) ||
isValidPCRelNode<JumpTableSDNode>(N) ||
isValidPCRelNode<BlockAddressSDNode>(N))
return true;
return false;
}
/// Returns true if we should use a direct load into vector instruction
/// (such as lxsd or lfd), instead of a load into gpr + direct move sequence.
static bool usePartialVectorLoads(SDNode *N, const PPCSubtarget& ST) {
// If there are any other uses other than scalar to vector, then we should
// keep it as a scalar load -> direct move pattern to prevent multiple
// loads.
LoadSDNode *LD = dyn_cast<LoadSDNode>(N);
if (!LD)
return false;
EVT MemVT = LD->getMemoryVT();
if (!MemVT.isSimple())
return false;
switch(MemVT.getSimpleVT().SimpleTy) {
case MVT::i64:
break;
case MVT::i32:
if (!ST.hasP8Vector())
return false;
break;
case MVT::i16:
case MVT::i8:
if (!ST.hasP9Vector())
return false;
break;
default:
return false;
}
SDValue LoadedVal(N, 0);
if (!LoadedVal.hasOneUse())
return false;
for (SDNode::use_iterator UI = LD->use_begin(), UE = LD->use_end();
UI != UE; ++UI)
if (UI.getUse().get().getResNo() == 0 &&
UI->getOpcode() != ISD::SCALAR_TO_VECTOR &&
UI->getOpcode() != PPCISD::SCALAR_TO_VECTOR_PERMUTED)
return false;
return true;
}
/// getPreIndexedAddressParts - returns true by value, base pointer and
/// offset pointer and addressing mode by reference if the node's address
/// can be legally represented as pre-indexed load / store address.
bool PPCTargetLowering::getPreIndexedAddressParts(SDNode *N, SDValue &Base,
SDValue &Offset,
ISD::MemIndexedMode &AM,
SelectionDAG &DAG) const {
if (DisablePPCPreinc) return false;
bool isLoad = true;
SDValue Ptr;
EVT VT;
unsigned Alignment;
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) {
Ptr = LD->getBasePtr();
VT = LD->getMemoryVT();
Alignment = LD->getAlignment();
} else if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
Ptr = ST->getBasePtr();
VT = ST->getMemoryVT();
Alignment = ST->getAlignment();
isLoad = false;
} else
return false;
// Do not generate pre-inc forms for specific loads that feed scalar_to_vector
// instructions because we can fold these into a more efficient instruction
// instead, (such as LXSD).
if (isLoad && usePartialVectorLoads(N, Subtarget)) {
return false;
}
// PowerPC doesn't have preinc load/store instructions for vectors
if (VT.isVector())
return false;
if (SelectAddressRegReg(Ptr, Base, Offset, DAG)) {
// Common code will reject creating a pre-inc form if the base pointer
// is a frame index, or if N is a store and the base pointer is either
// the same as or a predecessor of the value being stored. Check for
// those situations here, and try with swapped Base/Offset instead.
bool Swap = false;
if (isa<FrameIndexSDNode>(Base) || isa<RegisterSDNode>(Base))
Swap = true;
else if (!isLoad) {
SDValue Val = cast<StoreSDNode>(N)->getValue();
if (Val == Base || Base.getNode()->isPredecessorOf(Val.getNode()))
Swap = true;
}
if (Swap)
std::swap(Base, Offset);
AM = ISD::PRE_INC;
return true;
}
// LDU/STU can only handle immediates that are a multiple of 4.
if (VT != MVT::i64) {
if (!SelectAddressRegImm(Ptr, Offset, Base, DAG, None))
return false;
} else {
// LDU/STU need an address with at least 4-byte alignment.
if (Alignment < 4)
return false;
if (!SelectAddressRegImm(Ptr, Offset, Base, DAG, Align(4)))
return false;
}
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) {
// PPC64 doesn't have lwau, but it does have lwaux. Reject preinc load of
// sext i32 to i64 when addr mode is r+i.
if (LD->getValueType(0) == MVT::i64 && LD->getMemoryVT() == MVT::i32 &&
LD->getExtensionType() == ISD::SEXTLOAD &&
isa<ConstantSDNode>(Offset))
return false;
}
AM = ISD::PRE_INC;
return true;
}
//===----------------------------------------------------------------------===//
// LowerOperation implementation
//===----------------------------------------------------------------------===//
/// Return true if we should reference labels using a PICBase, set the HiOpFlags
/// and LoOpFlags to the target MO flags.
static void getLabelAccessInfo(bool IsPIC, const PPCSubtarget &Subtarget,
unsigned &HiOpFlags, unsigned &LoOpFlags,
const GlobalValue *GV = nullptr) {
HiOpFlags = PPCII::MO_HA;
LoOpFlags = PPCII::MO_LO;
// Don't use the pic base if not in PIC relocation model.
if (IsPIC) {
HiOpFlags |= PPCII::MO_PIC_FLAG;
LoOpFlags |= PPCII::MO_PIC_FLAG;
}
}
static SDValue LowerLabelRef(SDValue HiPart, SDValue LoPart, bool isPIC,
SelectionDAG &DAG) {
SDLoc DL(HiPart);
EVT PtrVT = HiPart.getValueType();
SDValue Zero = DAG.getConstant(0, DL, PtrVT);
SDValue Hi = DAG.getNode(PPCISD::Hi, DL, PtrVT, HiPart, Zero);
SDValue Lo = DAG.getNode(PPCISD::Lo, DL, PtrVT, LoPart, Zero);
// With PIC, the first instruction is actually "GR+hi(&G)".
if (isPIC)
Hi = DAG.getNode(ISD::ADD, DL, PtrVT,
DAG.getNode(PPCISD::GlobalBaseReg, DL, PtrVT), Hi);
// Generate non-pic code that has direct accesses to the constant pool.
// The address of the global is just (hi(&g)+lo(&g)).
return DAG.getNode(ISD::ADD, DL, PtrVT, Hi, Lo);
}
static void setUsesTOCBasePtr(MachineFunction &MF) {
PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
FuncInfo->setUsesTOCBasePtr();
}
static void setUsesTOCBasePtr(SelectionDAG &DAG) {
setUsesTOCBasePtr(DAG.getMachineFunction());
}
SDValue PPCTargetLowering::getTOCEntry(SelectionDAG &DAG, const SDLoc &dl,
SDValue GA) const {
const bool Is64Bit = Subtarget.isPPC64();
EVT VT = Is64Bit ? MVT::i64 : MVT::i32;
SDValue Reg = Is64Bit ? DAG.getRegister(PPC::X2, VT)
: Subtarget.isAIXABI()
? DAG.getRegister(PPC::R2, VT)
: DAG.getNode(PPCISD::GlobalBaseReg, dl, VT);
SDValue Ops[] = { GA, Reg };
return DAG.getMemIntrinsicNode(
PPCISD::TOC_ENTRY, dl, DAG.getVTList(VT, MVT::Other), Ops, VT,
MachinePointerInfo::getGOT(DAG.getMachineFunction()), None,
MachineMemOperand::MOLoad);
}
SDValue PPCTargetLowering::LowerConstantPool(SDValue Op,
SelectionDAG &DAG) const {
EVT PtrVT = Op.getValueType();
ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
const Constant *C = CP->getConstVal();
// 64-bit SVR4 ABI and AIX ABI code are always position-independent.
// The actual address of the GlobalValue is stored in the TOC.
if (Subtarget.is64BitELFABI() || Subtarget.isAIXABI()) {
if (Subtarget.isUsingPCRelativeCalls()) {
SDLoc DL(CP);
EVT Ty = getPointerTy(DAG.getDataLayout());
SDValue ConstPool = DAG.getTargetConstantPool(
C, Ty, CP->getAlign(), CP->getOffset(), PPCII::MO_PCREL_FLAG);
return DAG.getNode(PPCISD::MAT_PCREL_ADDR, DL, Ty, ConstPool);
}
setUsesTOCBasePtr(DAG);
SDValue GA = DAG.getTargetConstantPool(C, PtrVT, CP->getAlign(), 0);
return getTOCEntry(DAG, SDLoc(CP), GA);
}
unsigned MOHiFlag, MOLoFlag;
bool IsPIC = isPositionIndependent();
getLabelAccessInfo(IsPIC, Subtarget, MOHiFlag, MOLoFlag);
if (IsPIC && Subtarget.isSVR4ABI()) {
SDValue GA =
DAG.getTargetConstantPool(C, PtrVT, CP->getAlign(), PPCII::MO_PIC_FLAG);
return getTOCEntry(DAG, SDLoc(CP), GA);
}
SDValue CPIHi =
DAG.getTargetConstantPool(C, PtrVT, CP->getAlign(), 0, MOHiFlag);
SDValue CPILo =
DAG.getTargetConstantPool(C, PtrVT, CP->getAlign(), 0, MOLoFlag);
return LowerLabelRef(CPIHi, CPILo, IsPIC, DAG);
}
// For 64-bit PowerPC, prefer the more compact relative encodings.
// This trades 32 bits per jump table entry for one or two instructions
// on the jump site.
unsigned PPCTargetLowering::getJumpTableEncoding() const {
if (isJumpTableRelative())
return MachineJumpTableInfo::EK_LabelDifference32;
return TargetLowering::getJumpTableEncoding();
}
bool PPCTargetLowering::isJumpTableRelative() const {
if (UseAbsoluteJumpTables)
return false;
if (Subtarget.isPPC64() || Subtarget.isAIXABI())
return true;
return TargetLowering::isJumpTableRelative();
}
SDValue PPCTargetLowering::getPICJumpTableRelocBase(SDValue Table,
SelectionDAG &DAG) const {
if (!Subtarget.isPPC64() || Subtarget.isAIXABI())
return TargetLowering::getPICJumpTableRelocBase(Table, DAG);
switch (getTargetMachine().getCodeModel()) {
case CodeModel::Small:
case CodeModel::Medium:
return TargetLowering::getPICJumpTableRelocBase(Table, DAG);
default:
return DAG.getNode(PPCISD::GlobalBaseReg, SDLoc(),
getPointerTy(DAG.getDataLayout()));
}
}
const MCExpr *
PPCTargetLowering::getPICJumpTableRelocBaseExpr(const MachineFunction *MF,
unsigned JTI,
MCContext &Ctx) const {
if (!Subtarget.isPPC64() || Subtarget.isAIXABI())
return TargetLowering::getPICJumpTableRelocBaseExpr(MF, JTI, Ctx);
switch (getTargetMachine().getCodeModel()) {
case CodeModel::Small:
case CodeModel::Medium:
return TargetLowering::getPICJumpTableRelocBaseExpr(MF, JTI, Ctx);
default:
return MCSymbolRefExpr::create(MF->getPICBaseSymbol(), Ctx);
}
}
SDValue PPCTargetLowering::LowerJumpTable(SDValue Op, SelectionDAG &DAG) const {
EVT PtrVT = Op.getValueType();
JumpTableSDNode *JT = cast<JumpTableSDNode>(Op);
// isUsingPCRelativeCalls() returns true when PCRelative is enabled
if (Subtarget.isUsingPCRelativeCalls()) {
SDLoc DL(JT);
EVT Ty = getPointerTy(DAG.getDataLayout());
SDValue GA =
DAG.getTargetJumpTable(JT->getIndex(), Ty, PPCII::MO_PCREL_FLAG);
SDValue MatAddr = DAG.getNode(PPCISD::MAT_PCREL_ADDR, DL, Ty, GA);
return MatAddr;
}
// 64-bit SVR4 ABI and AIX ABI code are always position-independent.
// The actual address of the GlobalValue is stored in the TOC.
if (Subtarget.is64BitELFABI() || Subtarget.isAIXABI()) {
setUsesTOCBasePtr(DAG);
SDValue GA = DAG.getTargetJumpTable(JT->getIndex(), PtrVT);
return getTOCEntry(DAG, SDLoc(JT), GA);
}
unsigned MOHiFlag, MOLoFlag;
bool IsPIC = isPositionIndependent();
getLabelAccessInfo(IsPIC, Subtarget, MOHiFlag, MOLoFlag);
if (IsPIC && Subtarget.isSVR4ABI()) {
SDValue GA = DAG.getTargetJumpTable(JT->getIndex(), PtrVT,
PPCII::MO_PIC_FLAG);
return getTOCEntry(DAG, SDLoc(GA), GA);
}
SDValue JTIHi = DAG.getTargetJumpTable(JT->getIndex(), PtrVT, MOHiFlag);
SDValue JTILo = DAG.getTargetJumpTable(JT->getIndex(), PtrVT, MOLoFlag);
return LowerLabelRef(JTIHi, JTILo, IsPIC, DAG);
}
SDValue PPCTargetLowering::LowerBlockAddress(SDValue Op,
SelectionDAG &DAG) const {
EVT PtrVT = Op.getValueType();
BlockAddressSDNode *BASDN = cast<BlockAddressSDNode>(Op);
const BlockAddress *BA = BASDN->getBlockAddress();
// isUsingPCRelativeCalls() returns true when PCRelative is enabled
if (Subtarget.isUsingPCRelativeCalls()) {
SDLoc DL(BASDN);
EVT Ty = getPointerTy(DAG.getDataLayout());
SDValue GA = DAG.getTargetBlockAddress(BA, Ty, BASDN->getOffset(),
PPCII::MO_PCREL_FLAG);
SDValue MatAddr = DAG.getNode(PPCISD::MAT_PCREL_ADDR, DL, Ty, GA);
return MatAddr;
}
// 64-bit SVR4 ABI and AIX ABI code are always position-independent.
// The actual BlockAddress is stored in the TOC.
if (Subtarget.is64BitELFABI() || Subtarget.isAIXABI()) {
setUsesTOCBasePtr(DAG);
SDValue GA = DAG.getTargetBlockAddress(BA, PtrVT, BASDN->getOffset());
return getTOCEntry(DAG, SDLoc(BASDN), GA);
}
// 32-bit position-independent ELF stores the BlockAddress in the .got.
if (Subtarget.is32BitELFABI() && isPositionIndependent())
return getTOCEntry(
DAG, SDLoc(BASDN),
DAG.getTargetBlockAddress(BA, PtrVT, BASDN->getOffset()));
unsigned MOHiFlag, MOLoFlag;
bool IsPIC = isPositionIndependent();
getLabelAccessInfo(IsPIC, Subtarget, MOHiFlag, MOLoFlag);
SDValue TgtBAHi = DAG.getTargetBlockAddress(BA, PtrVT, 0, MOHiFlag);
SDValue TgtBALo = DAG.getTargetBlockAddress(BA, PtrVT, 0, MOLoFlag);
return LowerLabelRef(TgtBAHi, TgtBALo, IsPIC, DAG);
}
SDValue PPCTargetLowering::LowerGlobalTLSAddress(SDValue Op,
SelectionDAG &DAG) const {
if (Subtarget.isAIXABI())
return LowerGlobalTLSAddressAIX(Op, DAG);
return LowerGlobalTLSAddressLinux(Op, DAG);
}
SDValue PPCTargetLowering::LowerGlobalTLSAddressAIX(SDValue Op,
SelectionDAG &DAG) const {
GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
if (DAG.getTarget().useEmulatedTLS())
report_fatal_error("Emulated TLS is not yet supported on AIX");
SDLoc dl(GA);
const GlobalValue *GV = GA->getGlobal();
EVT PtrVT = getPointerTy(DAG.getDataLayout());
// The general-dynamic model is the only access model supported for now, so
// all the GlobalTLSAddress nodes are lowered with this model.
// We need to generate two TOC entries, one for the variable offset, one for
// the region handle. The global address for the TOC entry of the region
// handle is created with the MO_TLSGDM_FLAG flag and the global address
// for the TOC entry of the variable offset is created with MO_TLSGD_FLAG.
SDValue VariableOffsetTGA =
DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0, PPCII::MO_TLSGD_FLAG);
SDValue RegionHandleTGA =
DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0, PPCII::MO_TLSGDM_FLAG);
SDValue VariableOffset = getTOCEntry(DAG, dl, VariableOffsetTGA);
SDValue RegionHandle = getTOCEntry(DAG, dl, RegionHandleTGA);
return DAG.getNode(PPCISD::TLSGD_AIX, dl, PtrVT, VariableOffset,
RegionHandle);
}
SDValue PPCTargetLowering::LowerGlobalTLSAddressLinux(SDValue Op,
SelectionDAG &DAG) const {
// FIXME: TLS addresses currently use medium model code sequences,
// which is the most useful form. Eventually support for small and
// large models could be added if users need it, at the cost of
// additional complexity.
GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
if (DAG.getTarget().useEmulatedTLS())
return LowerToTLSEmulatedModel(GA, DAG);
SDLoc dl(GA);
const GlobalValue *GV = GA->getGlobal();
EVT PtrVT = getPointerTy(DAG.getDataLayout());
bool is64bit = Subtarget.isPPC64();
const Module *M = DAG.getMachineFunction().getFunction().getParent();
PICLevel::Level picLevel = M->getPICLevel();
const TargetMachine &TM = getTargetMachine();
TLSModel::Model Model = TM.getTLSModel(GV);
if (Model == TLSModel::LocalExec) {
if (Subtarget.isUsingPCRelativeCalls()) {
SDValue TLSReg = DAG.getRegister(PPC::X13, MVT::i64);
SDValue TGA = DAG.getTargetGlobalAddress(
GV, dl, PtrVT, 0, (PPCII::MO_PCREL_FLAG | PPCII::MO_TPREL_FLAG));
SDValue MatAddr =
DAG.getNode(PPCISD::TLS_LOCAL_EXEC_MAT_ADDR, dl, PtrVT, TGA);
return DAG.getNode(PPCISD::ADD_TLS, dl, PtrVT, TLSReg, MatAddr);
}
SDValue TGAHi = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0,
PPCII::MO_TPREL_HA);
SDValue TGALo = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0,
PPCII::MO_TPREL_LO);
SDValue TLSReg = is64bit ? DAG.getRegister(PPC::X13, MVT::i64)
: DAG.getRegister(PPC::R2, MVT::i32);
SDValue Hi = DAG.getNode(PPCISD::Hi, dl, PtrVT, TGAHi, TLSReg);
return DAG.getNode(PPCISD::Lo, dl, PtrVT, TGALo, Hi);
}
if (Model == TLSModel::InitialExec) {
bool IsPCRel = Subtarget.isUsingPCRelativeCalls();
SDValue TGA = DAG.getTargetGlobalAddress(
GV, dl, PtrVT, 0, IsPCRel ? PPCII::MO_GOT_TPREL_PCREL_FLAG : 0);
SDValue TGATLS = DAG.getTargetGlobalAddress(
GV, dl, PtrVT, 0,
IsPCRel ? (PPCII::MO_TLS | PPCII::MO_PCREL_FLAG) : PPCII::MO_TLS);
SDValue TPOffset;
if (IsPCRel) {
SDValue MatPCRel = DAG.getNode(PPCISD::MAT_PCREL_ADDR, dl, PtrVT, TGA);
TPOffset = DAG.getLoad(MVT::i64, dl, DAG.getEntryNode(), MatPCRel,
MachinePointerInfo());
} else {
SDValue GOTPtr;
if (is64bit) {
setUsesTOCBasePtr(DAG);
SDValue GOTReg = DAG.getRegister(PPC::X2, MVT::i64);
GOTPtr =
DAG.getNode(PPCISD::ADDIS_GOT_TPREL_HA, dl, PtrVT, GOTReg, TGA);
} else {
if (!TM.isPositionIndependent())
GOTPtr = DAG.getNode(PPCISD::PPC32_GOT, dl, PtrVT);
else if (picLevel == PICLevel::SmallPIC)
GOTPtr = DAG.getNode(PPCISD::GlobalBaseReg, dl, PtrVT);
else
GOTPtr = DAG.getNode(PPCISD::PPC32_PICGOT, dl, PtrVT);
}
TPOffset = DAG.getNode(PPCISD::LD_GOT_TPREL_L, dl, PtrVT, TGA, GOTPtr);
}
return DAG.getNode(PPCISD::ADD_TLS, dl, PtrVT, TPOffset, TGATLS);
}
if (Model == TLSModel::GeneralDynamic) {
if (Subtarget.isUsingPCRelativeCalls()) {
SDValue TGA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0,
PPCII::MO_GOT_TLSGD_PCREL_FLAG);
return DAG.getNode(PPCISD::TLS_DYNAMIC_MAT_PCREL_ADDR, dl, PtrVT, TGA);
}
SDValue TGA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0, 0);
SDValue GOTPtr;
if (is64bit) {
setUsesTOCBasePtr(DAG);
SDValue GOTReg = DAG.getRegister(PPC::X2, MVT::i64);
GOTPtr = DAG.getNode(PPCISD::ADDIS_TLSGD_HA, dl, PtrVT,
GOTReg, TGA);
} else {
if (picLevel == PICLevel::SmallPIC)
GOTPtr = DAG.getNode(PPCISD::GlobalBaseReg, dl, PtrVT);
else
GOTPtr = DAG.getNode(PPCISD::PPC32_PICGOT, dl, PtrVT);
}
return DAG.getNode(PPCISD::ADDI_TLSGD_L_ADDR, dl, PtrVT,
GOTPtr, TGA, TGA);
}
if (Model == TLSModel::LocalDynamic) {
if (Subtarget.isUsingPCRelativeCalls()) {
SDValue TGA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0,
PPCII::MO_GOT_TLSLD_PCREL_FLAG);
SDValue MatPCRel =
DAG.getNode(PPCISD::TLS_DYNAMIC_MAT_PCREL_ADDR, dl, PtrVT, TGA);
return DAG.getNode(PPCISD::PADDI_DTPREL, dl, PtrVT, MatPCRel, TGA);
}
SDValue TGA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0, 0);
SDValue GOTPtr;
if (is64bit) {
setUsesTOCBasePtr(DAG);
SDValue GOTReg = DAG.getRegister(PPC::X2, MVT::i64);
GOTPtr = DAG.getNode(PPCISD::ADDIS_TLSLD_HA, dl, PtrVT,
GOTReg, TGA);
} else {
if (picLevel == PICLevel::SmallPIC)
GOTPtr = DAG.getNode(PPCISD::GlobalBaseReg, dl, PtrVT);
else
GOTPtr = DAG.getNode(PPCISD::PPC32_PICGOT, dl, PtrVT);
}
SDValue TLSAddr = DAG.getNode(PPCISD::ADDI_TLSLD_L_ADDR, dl,
PtrVT, GOTPtr, TGA, TGA);
SDValue DtvOffsetHi = DAG.getNode(PPCISD::ADDIS_DTPREL_HA, dl,
PtrVT, TLSAddr, TGA);
return DAG.getNode(PPCISD::ADDI_DTPREL_L, dl, PtrVT, DtvOffsetHi, TGA);
}
llvm_unreachable("Unknown TLS model!");
}
SDValue PPCTargetLowering::LowerGlobalAddress(SDValue Op,
SelectionDAG &DAG) const {
EVT PtrVT = Op.getValueType();
GlobalAddressSDNode *GSDN = cast<GlobalAddressSDNode>(Op);
SDLoc DL(GSDN);
const GlobalValue *GV = GSDN->getGlobal();
// 64-bit SVR4 ABI & AIX ABI code is always position-independent.
// The actual address of the GlobalValue is stored in the TOC.
if (Subtarget.is64BitELFABI() || Subtarget.isAIXABI()) {
if (Subtarget.isUsingPCRelativeCalls()) {
EVT Ty = getPointerTy(DAG.getDataLayout());
if (isAccessedAsGotIndirect(Op)) {
SDValue GA = DAG.getTargetGlobalAddress(GV, DL, Ty, GSDN->getOffset(),
PPCII::MO_PCREL_FLAG |
PPCII::MO_GOT_FLAG);
SDValue MatPCRel = DAG.getNode(PPCISD::MAT_PCREL_ADDR, DL, Ty, GA);
SDValue Load = DAG.getLoad(MVT::i64, DL, DAG.getEntryNode(), MatPCRel,
MachinePointerInfo());
return Load;
} else {
SDValue GA = DAG.getTargetGlobalAddress(GV, DL, Ty, GSDN->getOffset(),
PPCII::MO_PCREL_FLAG);
return DAG.getNode(PPCISD::MAT_PCREL_ADDR, DL, Ty, GA);
}
}
setUsesTOCBasePtr(DAG);
SDValue GA = DAG.getTargetGlobalAddress(GV, DL, PtrVT, GSDN->getOffset());
return getTOCEntry(DAG, DL, GA);
}
unsigned MOHiFlag, MOLoFlag;
bool IsPIC = isPositionIndependent();
getLabelAccessInfo(IsPIC, Subtarget, MOHiFlag, MOLoFlag, GV);
if (IsPIC && Subtarget.isSVR4ABI()) {
SDValue GA = DAG.getTargetGlobalAddress(GV, DL, PtrVT,
GSDN->getOffset(),
PPCII::MO_PIC_FLAG);
return getTOCEntry(DAG, DL, GA);
}
SDValue GAHi =
DAG.getTargetGlobalAddress(GV, DL, PtrVT, GSDN->getOffset(), MOHiFlag);
SDValue GALo =
DAG.getTargetGlobalAddress(GV, DL, PtrVT, GSDN->getOffset(), MOLoFlag);
return LowerLabelRef(GAHi, GALo, IsPIC, DAG);
}
SDValue PPCTargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) const {
bool IsStrict = Op->isStrictFPOpcode();
ISD::CondCode CC =
cast<CondCodeSDNode>(Op.getOperand(IsStrict ? 3 : 2))->get();
SDValue LHS = Op.getOperand(IsStrict ? 1 : 0);
SDValue RHS = Op.getOperand(IsStrict ? 2 : 1);
SDValue Chain = IsStrict ? Op.getOperand(0) : SDValue();
EVT LHSVT = LHS.getValueType();
SDLoc dl(Op);
// Soften the setcc with libcall if it is fp128.
if (LHSVT == MVT::f128) {
assert(!Subtarget.hasP9Vector() &&
"SETCC for f128 is already legal under Power9!");
softenSetCCOperands(DAG, LHSVT, LHS, RHS, CC, dl, LHS, RHS, Chain,
Op->getOpcode() == ISD::STRICT_FSETCCS);
if (RHS.getNode())
LHS = DAG.getNode(ISD::SETCC, dl, Op.getValueType(), LHS, RHS,
DAG.getCondCode(CC));
if (IsStrict)
return DAG.getMergeValues({LHS, Chain}, dl);
return LHS;
}
assert(!IsStrict && "Don't know how to handle STRICT_FSETCC!");
if (Op.getValueType() == MVT::v2i64) {
// When the operands themselves are v2i64 values, we need to do something
// special because VSX has no underlying comparison operations for these.
if (LHS.getValueType() == MVT::v2i64) {
// Equality can be handled by casting to the legal type for Altivec
// comparisons, everything else needs to be expanded.
if (CC != ISD::SETEQ && CC != ISD::SETNE)
return SDValue();
SDValue SetCC32 = DAG.getSetCC(
dl, MVT::v4i32, DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, LHS),
DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, RHS), CC);
int ShuffV[] = {1, 0, 3, 2};
SDValue Shuff =
DAG.getVectorShuffle(MVT::v4i32, dl, SetCC32, SetCC32, ShuffV);
return DAG.getBitcast(MVT::v2i64,
DAG.getNode(CC == ISD::SETEQ ? ISD::AND : ISD::OR,
dl, MVT::v4i32, Shuff, SetCC32));
}
// We handle most of these in the usual way.
return Op;
}
// If we're comparing for equality to zero, expose the fact that this is
// implemented as a ctlz/srl pair on ppc, so that the dag combiner can
// fold the new nodes.
if (SDValue V = lowerCmpEqZeroToCtlzSrl(Op, DAG))
return V;
if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS)) {
// Leave comparisons against 0 and -1 alone for now, since they're usually
// optimized. FIXME: revisit this when we can custom lower all setcc
// optimizations.
if (C->isAllOnes() || C->isZero())
return SDValue();
}
// If we have an integer seteq/setne, turn it into a compare against zero
// by xor'ing the rhs with the lhs, which is faster than setting a
// condition register, reading it back out, and masking the correct bit. The
// normal approach here uses sub to do this instead of xor. Using xor exposes
// the result to other bit-twiddling opportunities.
if (LHSVT.isInteger() && (CC == ISD::SETEQ || CC == ISD::SETNE)) {
EVT VT = Op.getValueType();
SDValue Sub = DAG.getNode(ISD::XOR, dl, LHSVT, LHS, RHS);
return DAG.getSetCC(dl, VT, Sub, DAG.getConstant(0, dl, LHSVT), CC);
}
return SDValue();
}
SDValue PPCTargetLowering::LowerVAARG(SDValue Op, SelectionDAG &DAG) const {
SDNode *Node = Op.getNode();
EVT VT = Node->getValueType(0);
EVT PtrVT = getPointerTy(DAG.getDataLayout());
SDValue InChain = Node->getOperand(0);
SDValue VAListPtr = Node->getOperand(1);
const Value *SV = cast<SrcValueSDNode>(Node->getOperand(2))->getValue();
SDLoc dl(Node);
assert(!Subtarget.isPPC64() && "LowerVAARG is PPC32 only");
// gpr_index
SDValue GprIndex = DAG.getExtLoad(ISD::ZEXTLOAD, dl, MVT::i32, InChain,
VAListPtr, MachinePointerInfo(SV), MVT::i8);
InChain = GprIndex.getValue(1);
if (VT == MVT::i64) {
// Check if GprIndex is even
SDValue GprAnd = DAG.getNode(ISD::AND, dl, MVT::i32, GprIndex,
DAG.getConstant(1, dl, MVT::i32));
SDValue CC64 = DAG.getSetCC(dl, MVT::i32, GprAnd,
DAG.getConstant(0, dl, MVT::i32), ISD::SETNE);
SDValue GprIndexPlusOne = DAG.getNode(ISD::ADD, dl, MVT::i32, GprIndex,
DAG.getConstant(1, dl, MVT::i32));
// Align GprIndex to be even if it isn't
GprIndex = DAG.getNode(ISD::SELECT, dl, MVT::i32, CC64, GprIndexPlusOne,
GprIndex);
}
// fpr index is 1 byte after gpr
SDValue FprPtr = DAG.getNode(ISD::ADD, dl, PtrVT, VAListPtr,
DAG.getConstant(1, dl, MVT::i32));
// fpr
SDValue FprIndex = DAG.getExtLoad(ISD::ZEXTLOAD, dl, MVT::i32, InChain,
FprPtr, MachinePointerInfo(SV), MVT::i8);
InChain = FprIndex.getValue(1);
SDValue RegSaveAreaPtr = DAG.getNode(ISD::ADD, dl, PtrVT, VAListPtr,
DAG.getConstant(8, dl, MVT::i32));
SDValue OverflowAreaPtr = DAG.getNode(ISD::ADD, dl, PtrVT, VAListPtr,
DAG.getConstant(4, dl, MVT::i32));
// areas
SDValue OverflowArea =
DAG.getLoad(MVT::i32, dl, InChain, OverflowAreaPtr, MachinePointerInfo());
InChain = OverflowArea.getValue(1);
SDValue RegSaveArea =
DAG.getLoad(MVT::i32, dl, InChain, RegSaveAreaPtr, MachinePointerInfo());
InChain = RegSaveArea.getValue(1);
// select overflow_area if index > 8
SDValue CC = DAG.getSetCC(dl, MVT::i32, VT.isInteger() ? GprIndex : FprIndex,
DAG.getConstant(8, dl, MVT::i32), ISD::SETLT);
// adjustment constant gpr_index * 4/8
SDValue RegConstant = DAG.getNode(ISD::MUL, dl, MVT::i32,
VT.isInteger() ? GprIndex : FprIndex,
DAG.getConstant(VT.isInteger() ? 4 : 8, dl,
MVT::i32));
// OurReg = RegSaveArea + RegConstant
SDValue OurReg = DAG.getNode(ISD::ADD, dl, PtrVT, RegSaveArea,
RegConstant);
// Floating types are 32 bytes into RegSaveArea
if (VT.isFloatingPoint())
OurReg = DAG.getNode(ISD::ADD, dl, PtrVT, OurReg,
DAG.getConstant(32, dl, MVT::i32));
// increase {f,g}pr_index by 1 (or 2 if VT is i64)
SDValue IndexPlus1 = DAG.getNode(ISD::ADD, dl, MVT::i32,
VT.isInteger() ? GprIndex : FprIndex,
DAG.getConstant(VT == MVT::i64 ? 2 : 1, dl,
MVT::i32));
InChain = DAG.getTruncStore(InChain, dl, IndexPlus1,
VT.isInteger() ? VAListPtr : FprPtr,
MachinePointerInfo(SV), MVT::i8);
// determine if we should load from reg_save_area or overflow_area
SDValue Result = DAG.getNode(ISD::SELECT, dl, PtrVT, CC, OurReg, OverflowArea);
// increase overflow_area by 4/8 if gpr/fpr > 8
SDValue OverflowAreaPlusN = DAG.getNode(ISD::ADD, dl, PtrVT, OverflowArea,
DAG.getConstant(VT.isInteger() ? 4 : 8,
dl, MVT::i32));
OverflowArea = DAG.getNode(ISD::SELECT, dl, MVT::i32, CC, OverflowArea,
OverflowAreaPlusN);
InChain = DAG.getTruncStore(InChain, dl, OverflowArea, OverflowAreaPtr,
MachinePointerInfo(), MVT::i32);
return DAG.getLoad(VT, dl, InChain, Result, MachinePointerInfo());
}
SDValue PPCTargetLowering::LowerVACOPY(SDValue Op, SelectionDAG &DAG) const {
assert(!Subtarget.isPPC64() && "LowerVACOPY is PPC32 only");
// We have to copy the entire va_list struct:
// 2*sizeof(char) + 2 Byte alignment + 2*sizeof(char*) = 12 Byte
return DAG.getMemcpy(Op.getOperand(0), Op, Op.getOperand(1), Op.getOperand(2),
DAG.getConstant(12, SDLoc(Op), MVT::i32), Align(8),
false, true, false, MachinePointerInfo(),
MachinePointerInfo());
}
SDValue PPCTargetLowering::LowerADJUST_TRAMPOLINE(SDValue Op,
SelectionDAG &DAG) const {
if (Subtarget.isAIXABI())
report_fatal_error("ADJUST_TRAMPOLINE operation is not supported on AIX.");
return Op.getOperand(0);
}
SDValue PPCTargetLowering::LowerINLINEASM(SDValue Op, SelectionDAG &DAG) const {
MachineFunction &MF = DAG.getMachineFunction();
PPCFunctionInfo &MFI = *MF.getInfo<PPCFunctionInfo>();
assert((Op.getOpcode() == ISD::INLINEASM ||
Op.getOpcode() == ISD::INLINEASM_BR) &&
"Expecting Inline ASM node.");
// If an LR store is already known to be required then there is not point in
// checking this ASM as well.
if (MFI.isLRStoreRequired())
return Op;
// Inline ASM nodes have an optional last operand that is an incoming Flag of
// type MVT::Glue. We want to ignore this last operand if that is the case.
unsigned NumOps = Op.getNumOperands();
if (Op.getOperand(NumOps - 1).getValueType() == MVT::Glue)
--NumOps;
// Check all operands that may contain the LR.
for (unsigned i = InlineAsm::Op_FirstOperand; i != NumOps;) {
unsigned Flags = cast<ConstantSDNode>(Op.getOperand(i))->getZExtValue();
unsigned NumVals = InlineAsm::getNumOperandRegisters(Flags);
++i; // Skip the ID value.
switch (InlineAsm::getKind(Flags)) {
default:
llvm_unreachable("Bad flags!");
case InlineAsm::Kind_RegUse:
case InlineAsm::Kind_Imm:
case InlineAsm::Kind_Mem:
i += NumVals;
break;
case InlineAsm::Kind_Clobber:
case InlineAsm::Kind_RegDef:
case InlineAsm::Kind_RegDefEarlyClobber: {
for (; NumVals; --NumVals, ++i) {
Register Reg = cast<RegisterSDNode>(Op.getOperand(i))->getReg();
if (Reg != PPC::LR && Reg != PPC::LR8)
continue;
MFI.setLRStoreRequired();
return Op;
}
break;
}
}
}
return Op;
}
SDValue PPCTargetLowering::LowerINIT_TRAMPOLINE(SDValue Op,
SelectionDAG &DAG) const {
if (Subtarget.isAIXABI())
report_fatal_error("INIT_TRAMPOLINE operation is not supported on AIX.");
SDValue Chain = Op.getOperand(0);
SDValue Trmp = Op.getOperand(1); // trampoline
SDValue FPtr = Op.getOperand(2); // nested function
SDValue Nest = Op.getOperand(3); // 'nest' parameter value
SDLoc dl(Op);
EVT PtrVT = getPointerTy(DAG.getDataLayout());
bool isPPC64 = (PtrVT == MVT::i64);
Type *IntPtrTy = DAG.getDataLayout().getIntPtrType(*DAG.getContext());
TargetLowering::ArgListTy Args;
TargetLowering::ArgListEntry Entry;
Entry.Ty = IntPtrTy;
Entry.Node = Trmp; Args.push_back(Entry);
// TrampSize == (isPPC64 ? 48 : 40);
Entry.Node = DAG.getConstant(isPPC64 ? 48 : 40, dl,
isPPC64 ? MVT::i64 : MVT::i32);
Args.push_back(Entry);
Entry.Node = FPtr; Args.push_back(Entry);
Entry.Node = Nest; Args.push_back(Entry);
// Lower to a call to __trampoline_setup(Trmp, TrampSize, FPtr, ctx_reg)
TargetLowering::CallLoweringInfo CLI(DAG);
CLI.setDebugLoc(dl).setChain(Chain).setLibCallee(
CallingConv::C, Type::getVoidTy(*DAG.getContext()),
DAG.getExternalSymbol("__trampoline_setup", PtrVT), std::move(Args));
std::pair<SDValue, SDValue> CallResult = LowerCallTo(CLI);
return CallResult.second;
}
SDValue PPCTargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG) const {
MachineFunction &MF = DAG.getMachineFunction();
PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
EVT PtrVT = getPointerTy(MF.getDataLayout());
SDLoc dl(Op);
if (Subtarget.isPPC64() || Subtarget.isAIXABI()) {
// vastart just stores the address of the VarArgsFrameIndex slot into the
// memory location argument.
SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
return DAG.getStore(Op.getOperand(0), dl, FR, Op.getOperand(1),
MachinePointerInfo(SV));
}
// For the 32-bit SVR4 ABI we follow the layout of the va_list struct.
// We suppose the given va_list is already allocated.
//
// typedef struct {
// char gpr; /* index into the array of 8 GPRs
// * stored in the register save area
// * gpr=0 corresponds to r3,
// * gpr=1 to r4, etc.
// */
// char fpr; /* index into the array of 8 FPRs
// * stored in the register save area
// * fpr=0 corresponds to f1,
// * fpr=1 to f2, etc.
// */
// char *overflow_arg_area;
// /* location on stack that holds
// * the next overflow argument
// */
// char *reg_save_area;
// /* where r3:r10 and f1:f8 (if saved)
// * are stored
// */
// } va_list[1];
SDValue ArgGPR = DAG.getConstant(FuncInfo->getVarArgsNumGPR(), dl, MVT::i32);
SDValue ArgFPR = DAG.getConstant(FuncInfo->getVarArgsNumFPR(), dl, MVT::i32);
SDValue StackOffsetFI = DAG.getFrameIndex(FuncInfo->getVarArgsStackOffset(),
PtrVT);
SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
PtrVT);
uint64_t FrameOffset = PtrVT.getSizeInBits()/8;
SDValue ConstFrameOffset = DAG.getConstant(FrameOffset, dl, PtrVT);
uint64_t StackOffset = PtrVT.getSizeInBits()/8 - 1;
SDValue ConstStackOffset = DAG.getConstant(StackOffset, dl, PtrVT);
uint64_t FPROffset = 1;
SDValue ConstFPROffset = DAG.getConstant(FPROffset, dl, PtrVT);
const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
// Store first byte : number of int regs
SDValue firstStore =
DAG.getTruncStore(Op.getOperand(0), dl, ArgGPR, Op.getOperand(1),
MachinePointerInfo(SV), MVT::i8);
uint64_t nextOffset = FPROffset;
SDValue nextPtr = DAG.getNode(ISD::ADD, dl, PtrVT, Op.getOperand(1),
ConstFPROffset);
// Store second byte : number of float regs
SDValue secondStore =
DAG.getTruncStore(firstStore, dl, ArgFPR, nextPtr,
MachinePointerInfo(SV, nextOffset), MVT::i8);
nextOffset += StackOffset;
nextPtr = DAG.getNode(ISD::ADD, dl, PtrVT, nextPtr, ConstStackOffset);
// Store second word : arguments given on stack
SDValue thirdStore = DAG.getStore(secondStore, dl, StackOffsetFI, nextPtr,
MachinePointerInfo(SV, nextOffset));
nextOffset += FrameOffset;
nextPtr = DAG.getNode(ISD::ADD, dl, PtrVT, nextPtr, ConstFrameOffset);
// Store third word : arguments given in registers
return DAG.getStore(thirdStore, dl, FR, nextPtr,
MachinePointerInfo(SV, nextOffset));
}
/// FPR - The set of FP registers that should be allocated for arguments
/// on Darwin and AIX.
static const MCPhysReg FPR[] = {PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5,
PPC::F6, PPC::F7, PPC::F8, PPC::F9, PPC::F10,
PPC::F11, PPC::F12, PPC::F13};
/// CalculateStackSlotSize - Calculates the size reserved for this argument on
/// the stack.
static unsigned CalculateStackSlotSize(EVT ArgVT, ISD::ArgFlagsTy Flags,
unsigned PtrByteSize) {
unsigned ArgSize = ArgVT.getStoreSize();
if (Flags.isByVal())
ArgSize = Flags.getByValSize();
// Round up to multiples of the pointer size, except for array members,
// which are always packed.
if (!Flags.isInConsecutiveRegs())
ArgSize = ((ArgSize + PtrByteSize - 1)/PtrByteSize) * PtrByteSize;
return ArgSize;
}
/// CalculateStackSlotAlignment - Calculates the alignment of this argument
/// on the stack.
static Align CalculateStackSlotAlignment(EVT ArgVT, EVT OrigVT,
ISD::ArgFlagsTy Flags,
unsigned PtrByteSize) {
Align Alignment(PtrByteSize);
// Altivec parameters are padded to a 16 byte boundary.
if (ArgVT == MVT::v4f32 || ArgVT == MVT::v4i32 ||
ArgVT == MVT::v8i16 || ArgVT == MVT::v16i8 ||
ArgVT == MVT::v2f64 || ArgVT == MVT::v2i64 ||
ArgVT == MVT::v1i128 || ArgVT == MVT::f128)
Alignment = Align(16);
// ByVal parameters are aligned as requested.
if (Flags.isByVal()) {
auto BVAlign = Flags.getNonZeroByValAlign();
if (BVAlign > PtrByteSize) {
if (BVAlign.value() % PtrByteSize != 0)
llvm_unreachable(
"ByVal alignment is not a multiple of the pointer size");
Alignment = BVAlign;
}
}
// Array members are always packed to their original alignment.
if (Flags.isInConsecutiveRegs()) {
// If the array member was split into multiple registers, the first
// needs to be aligned to the size of the full type. (Except for
// ppcf128, which is only aligned as its f64 components.)
if (Flags.isSplit() && OrigVT != MVT::ppcf128)
Alignment = Align(OrigVT.getStoreSize());
else
Alignment = Align(ArgVT.getStoreSize());
}
return Alignment;
}
/// CalculateStackSlotUsed - Return whether this argument will use its
/// stack slot (instead of being passed in registers). ArgOffset,
/// AvailableFPRs, and AvailableVRs must hold the current argument
/// position, and will be updated to account for this argument.
static bool CalculateStackSlotUsed(EVT ArgVT, EVT OrigVT, ISD::ArgFlagsTy Flags,
unsigned PtrByteSize, unsigned LinkageSize,
unsigned ParamAreaSize, unsigned &ArgOffset,
unsigned &AvailableFPRs,
unsigned &AvailableVRs) {
bool UseMemory = false;
// Respect alignment of argument on the stack.
Align Alignment =
CalculateStackSlotAlignment(ArgVT, OrigVT, Flags, PtrByteSize);
ArgOffset = alignTo(ArgOffset, Alignment);
// If there's no space left in the argument save area, we must
// use memory (this check also catches zero-sized arguments).
if (ArgOffset >= LinkageSize + ParamAreaSize)
UseMemory = true;
// Allocate argument on the stack.
ArgOffset += CalculateStackSlotSize(ArgVT, Flags, PtrByteSize);
if (Flags.isInConsecutiveRegsLast())
ArgOffset = ((ArgOffset + PtrByteSize - 1)/PtrByteSize) * PtrByteSize;
// If we overran the argument save area, we must use memory
// (this check catches arguments passed partially in memory)
if (ArgOffset > LinkageSize + ParamAreaSize)
UseMemory = true;
// However, if the argument is actually passed in an FPR or a VR,
// we don't use memory after all.
if (!Flags.isByVal()) {
if (ArgVT == MVT::f32 || ArgVT == MVT::f64)
if (AvailableFPRs > 0) {
--AvailableFPRs;
return false;
}
if (ArgVT == MVT::v4f32 || ArgVT == MVT::v4i32 ||
ArgVT == MVT::v8i16 || ArgVT == MVT::v16i8 ||
ArgVT == MVT::v2f64 || ArgVT == MVT::v2i64 ||
ArgVT == MVT::v1i128 || ArgVT == MVT::f128)
if (AvailableVRs > 0) {
--AvailableVRs;
return false;
}
}
return UseMemory;
}
/// EnsureStackAlignment - Round stack frame size up from NumBytes to
/// ensure minimum alignment required for target.
static unsigned EnsureStackAlignment(const PPCFrameLowering *Lowering,
unsigned NumBytes) {
return alignTo(NumBytes, Lowering->getStackAlign());
}
SDValue PPCTargetLowering::LowerFormalArguments(
SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const {
if (Subtarget.isAIXABI())
return LowerFormalArguments_AIX(Chain, CallConv, isVarArg, Ins, dl, DAG,
InVals);
if (Subtarget.is64BitELFABI())
return LowerFormalArguments_64SVR4(Chain, CallConv, isVarArg, Ins, dl, DAG,
InVals);
assert(Subtarget.is32BitELFABI());
return LowerFormalArguments_32SVR4(Chain, CallConv, isVarArg, Ins, dl, DAG,
InVals);
}
SDValue PPCTargetLowering::LowerFormalArguments_32SVR4(
SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const {
// 32-bit SVR4 ABI Stack Frame Layout:
// +-----------------------------------+
// +--> | Back chain |
// | +-----------------------------------+
// | | Floating-point register save area |
// | +-----------------------------------+
// | | General register save area |
// | +-----------------------------------+
// | | CR save word |
// | +-----------------------------------+
// | | VRSAVE save word |
// | +-----------------------------------+
// | | Alignment padding |
// | +-----------------------------------+
// | | Vector register save area |
// | +-----------------------------------+
// | | Local variable space |
// | +-----------------------------------+
// | | Parameter list area |
// | +-----------------------------------+
// | | LR save word |
// | +-----------------------------------+
// SP--> +--- | Back chain |
// +-----------------------------------+
//
// Specifications:
// System V Application Binary Interface PowerPC Processor Supplement
// AltiVec Technology Programming Interface Manual
MachineFunction &MF = DAG.getMachineFunction();
MachineFrameInfo &MFI = MF.getFrameInfo();
PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
EVT PtrVT = getPointerTy(MF.getDataLayout());
// Potential tail calls could cause overwriting of argument stack slots.
bool isImmutable = !(getTargetMachine().Options.GuaranteedTailCallOpt &&
(CallConv == CallingConv::Fast));
const Align PtrAlign(4);
// Assign locations to all of the incoming arguments.
SmallVector<CCValAssign, 16> ArgLocs;
PPCCCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(), ArgLocs,
*DAG.getContext());
// Reserve space for the linkage area on the stack.
unsigned LinkageSize = Subtarget.getFrameLowering()->getLinkageSize();
CCInfo.AllocateStack(LinkageSize, PtrAlign);
if (useSoftFloat())
CCInfo.PreAnalyzeFormalArguments(Ins);
CCInfo.AnalyzeFormalArguments(Ins, CC_PPC32_SVR4);
CCInfo.clearWasPPCF128();
for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
CCValAssign &VA = ArgLocs[i];
// Arguments stored in registers.
if (VA.isRegLoc()) {
const TargetRegisterClass *RC;
EVT ValVT = VA.getValVT();
switch (ValVT.getSimpleVT().SimpleTy) {
default:
llvm_unreachable("ValVT not supported by formal arguments Lowering");
case MVT::i1:
case MVT::i32:
RC = &PPC::GPRCRegClass;
break;
case MVT::f32:
if (Subtarget.hasP8Vector())
RC = &PPC::VSSRCRegClass;
else if (Subtarget.hasSPE())
RC = &PPC::GPRCRegClass;
else
RC = &PPC::F4RCRegClass;
break;
case MVT::f64:
if (Subtarget.hasVSX())
RC = &PPC::VSFRCRegClass;
else if (Subtarget.hasSPE())
// SPE passes doubles in GPR pairs.
RC = &PPC::GPRCRegClass;
else
RC = &PPC::F8RCRegClass;
break;
case MVT::v16i8:
case MVT::v8i16:
case MVT::v4i32:
RC = &PPC::VRRCRegClass;
break;
case MVT::v4f32:
RC = &PPC::VRRCRegClass;
break;
case MVT::v2f64:
case MVT::v2i64:
RC = &PPC::VRRCRegClass;
break;
}
SDValue ArgValue;
// Transform the arguments stored in physical registers into
// virtual ones.
if (VA.getLocVT() == MVT::f64 && Subtarget.hasSPE()) {
assert(i + 1 < e && "No second half of double precision argument");
Register RegLo = MF.addLiveIn(VA.getLocReg(), RC);
Register RegHi = MF.addLiveIn(ArgLocs[++i].getLocReg(), RC);
SDValue ArgValueLo = DAG.getCopyFromReg(Chain, dl, RegLo, MVT::i32);
SDValue ArgValueHi = DAG.getCopyFromReg(Chain, dl, RegHi, MVT::i32);
if (!Subtarget.isLittleEndian())
std::swap (ArgValueLo, ArgValueHi);
ArgValue = DAG.getNode(PPCISD::BUILD_SPE64, dl, MVT::f64, ArgValueLo,
ArgValueHi);
} else {
Register Reg = MF.addLiveIn(VA.getLocReg(), RC);
ArgValue = DAG.getCopyFromReg(Chain, dl, Reg,
ValVT == MVT::i1 ? MVT::i32 : ValVT);
if (ValVT == MVT::i1)
ArgValue = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, ArgValue);
}
InVals.push_back(ArgValue);
} else {
// Argument stored in memory.
assert(VA.isMemLoc());
// Get the extended size of the argument type in stack
unsigned ArgSize = VA.getLocVT().getStoreSize();
// Get the actual size of the argument type
unsigned ObjSize = VA.getValVT().getStoreSize();
unsigned ArgOffset = VA.getLocMemOffset();
// Stack objects in PPC32 are right justified.
ArgOffset += ArgSize - ObjSize;
int FI = MFI.CreateFixedObject(ArgSize, ArgOffset, isImmutable);
// Create load nodes to retrieve arguments from the stack.
SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
InVals.push_back(
DAG.getLoad(VA.getValVT(), dl, Chain, FIN, MachinePointerInfo()));
}
}
// Assign locations to all of the incoming aggregate by value arguments.
// Aggregates passed by value are stored in the local variable space of the
// caller's stack frame, right above the parameter list area.
SmallVector<CCValAssign, 16> ByValArgLocs;
CCState CCByValInfo(CallConv, isVarArg, DAG.getMachineFunction(),
ByValArgLocs, *DAG.getContext());
// Reserve stack space for the allocations in CCInfo.
CCByValInfo.AllocateStack(CCInfo.getNextStackOffset(), PtrAlign);
CCByValInfo.AnalyzeFormalArguments(Ins, CC_PPC32_SVR4_ByVal);
// Area that is at least reserved in the caller of this function.
unsigned MinReservedArea = CCByValInfo.getNextStackOffset();
MinReservedArea = std::max(MinReservedArea, LinkageSize);
// Set the size that is at least reserved in caller of this function. Tail
// call optimized function's reserved stack space needs to be aligned so that
// taking the difference between two stack areas will result in an aligned
// stack.
MinReservedArea =
EnsureStackAlignment(Subtarget.getFrameLowering(), MinReservedArea);
FuncInfo->setMinReservedArea(MinReservedArea);
SmallVector<SDValue, 8> MemOps;
// If the function takes variable number of arguments, make a frame index for
// the start of the first vararg value... for expansion of llvm.va_start.
if (isVarArg) {
static const MCPhysReg GPArgRegs[] = {
PPC::R3, PPC::R4, PPC::R5, PPC::R6,
PPC::R7, PPC::R8, PPC::R9, PPC::R10,
};
const unsigned NumGPArgRegs = array_lengthof(GPArgRegs);
static const MCPhysReg FPArgRegs[] = {
PPC::F1, PPC::F2, PPC::F3, PPC::F4, PPC::F5, PPC::F6, PPC::F7,
PPC::F8
};
unsigned NumFPArgRegs = array_lengthof(FPArgRegs);
if (useSoftFloat() || hasSPE())
NumFPArgRegs = 0;
FuncInfo->setVarArgsNumGPR(CCInfo.getFirstUnallocated(GPArgRegs));
FuncInfo->setVarArgsNumFPR(CCInfo.getFirstUnallocated(FPArgRegs));
// Make room for NumGPArgRegs and NumFPArgRegs.
int Depth = NumGPArgRegs * PtrVT.getSizeInBits()/8 +
NumFPArgRegs * MVT(MVT::f64).getSizeInBits()/8;
FuncInfo->setVarArgsStackOffset(
MFI.CreateFixedObject(PtrVT.getSizeInBits()/8,
CCInfo.getNextStackOffset(), true));
FuncInfo->setVarArgsFrameIndex(
MFI.CreateStackObject(Depth, Align(8), false));
SDValue FIN = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
// The fixed integer arguments of a variadic function are stored to the
// VarArgsFrameIndex on the stack so that they may be loaded by
// dereferencing the result of va_next.
for (unsigned GPRIndex = 0; GPRIndex != NumGPArgRegs; ++GPRIndex) {
// Get an existing live-in vreg, or add a new one.
Register VReg = MF.getRegInfo().getLiveInVirtReg(GPArgRegs[GPRIndex]);
if (!VReg)
VReg = MF.addLiveIn(GPArgRegs[GPRIndex], &PPC::GPRCRegClass);
SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
SDValue Store =
DAG.getStore(Val.getValue(1), dl, Val, FIN, MachinePointerInfo());
MemOps.push_back(Store);
// Increment the address by four for the next argument to store
SDValue PtrOff = DAG.getConstant(PtrVT.getSizeInBits()/8, dl, PtrVT);
FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
}
// FIXME 32-bit SVR4: We only need to save FP argument registers if CR bit 6
// is set.
// The double arguments are stored to the VarArgsFrameIndex
// on the stack.
for (unsigned FPRIndex = 0; FPRIndex != NumFPArgRegs; ++FPRIndex) {
// Get an existing live-in vreg, or add a new one.
Register VReg = MF.getRegInfo().getLiveInVirtReg(FPArgRegs[FPRIndex]);
if (!VReg)
VReg = MF.addLiveIn(FPArgRegs[FPRIndex], &PPC::F8RCRegClass);
SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, MVT::f64);
SDValue Store =
DAG.getStore(Val.getValue(1), dl, Val, FIN, MachinePointerInfo());
MemOps.push_back(Store);
// Increment the address by eight for the next argument to store
SDValue PtrOff = DAG.getConstant(MVT(MVT::f64).getSizeInBits()/8, dl,
PtrVT);
FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
}
}
if (!MemOps.empty())
Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
return Chain;
}
// PPC64 passes i8, i16, and i32 values in i64 registers. Promote
// value to MVT::i64 and then truncate to the correct register size.
SDValue PPCTargetLowering::extendArgForPPC64(ISD::ArgFlagsTy Flags,
EVT ObjectVT, SelectionDAG &DAG,
SDValue ArgVal,
const SDLoc &dl) const {
if (Flags.isSExt())
ArgVal = DAG.getNode(ISD::AssertSext, dl, MVT::i64, ArgVal,
DAG.getValueType(ObjectVT));
else if (Flags.isZExt())
ArgVal = DAG.getNode(ISD::AssertZext, dl, MVT::i64, ArgVal,
DAG.getValueType(ObjectVT));
return DAG.getNode(ISD::TRUNCATE, dl, ObjectVT, ArgVal);
}
SDValue PPCTargetLowering::LowerFormalArguments_64SVR4(
SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const {
// TODO: add description of PPC stack frame format, or at least some docs.
//
bool isELFv2ABI = Subtarget.isELFv2ABI();
bool isLittleEndian = Subtarget.isLittleEndian();
MachineFunction &MF = DAG.getMachineFunction();
MachineFrameInfo &MFI = MF.getFrameInfo();
PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
assert(!(CallConv == CallingConv::Fast && isVarArg) &&
"fastcc not supported on varargs functions");
EVT PtrVT = getPointerTy(MF.getDataLayout());
// Potential tail calls could cause overwriting of argument stack slots.
bool isImmutable = !(getTargetMachine().Options.GuaranteedTailCallOpt &&
(CallConv == CallingConv::Fast));
unsigned PtrByteSize = 8;
unsigned LinkageSize = Subtarget.getFrameLowering()->getLinkageSize();
static const MCPhysReg GPR[] = {
PPC::X3, PPC::X4, PPC::X5, PPC::X6,
PPC::X7, PPC::X8, PPC::X9, PPC::X10,
};
static const MCPhysReg VR[] = {
PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8,
PPC::V9, PPC::V10, PPC::V11, PPC::V12, PPC::V13
};
const unsigned Num_GPR_Regs = array_lengthof(GPR);
const unsigned Num_FPR_Regs = useSoftFloat() ? 0 : 13;
const unsigned Num_VR_Regs = array_lengthof(VR);
// Do a first pass over the arguments to determine whether the ABI
// guarantees that our caller has allocated the parameter save area
// on its stack frame. In the ELFv1 ABI, this is always the case;
// in the ELFv2 ABI, it is true if this is a vararg function or if
// any parameter is located in a stack slot.
bool HasParameterArea = !isELFv2ABI || isVarArg;
unsigned ParamAreaSize = Num_GPR_Regs * PtrByteSize;
unsigned NumBytes = LinkageSize;
unsigned AvailableFPRs = Num_FPR_Regs;
unsigned AvailableVRs = Num_VR_Regs;
for (unsigned i = 0, e = Ins.size(); i != e; ++i) {
if (Ins[i].Flags.isNest())
continue;
if (CalculateStackSlotUsed(Ins[i].VT, Ins[i].ArgVT, Ins[i].Flags,
PtrByteSize, LinkageSize, ParamAreaSize,
NumBytes, AvailableFPRs, AvailableVRs))
HasParameterArea = true;
}
// Add DAG nodes to load the arguments or copy them out of registers. On
// entry to a function on PPC, the arguments start after the linkage area,
// although the first ones are often in registers.
unsigned ArgOffset = LinkageSize;
unsigned GPR_idx = 0, FPR_idx = 0, VR_idx = 0;
SmallVector<SDValue, 8> MemOps;
Function::const_arg_iterator FuncArg = MF.getFunction().arg_begin();
unsigned CurArgIdx = 0;
for (unsigned ArgNo = 0, e = Ins.size(); ArgNo != e; ++ArgNo) {
SDValue ArgVal;
bool needsLoad = false;
EVT ObjectVT = Ins[ArgNo].VT;
EVT OrigVT = Ins[ArgNo].ArgVT;
unsigned ObjSize = ObjectVT.getStoreSize();
unsigned ArgSize = ObjSize;
ISD::ArgFlagsTy Flags = Ins[ArgNo].Flags;
if (Ins[ArgNo].isOrigArg()) {
std::advance(FuncArg, Ins[ArgNo].getOrigArgIndex() - CurArgIdx);
CurArgIdx = Ins[ArgNo].getOrigArgIndex();
}
// We re-align the argument offset for each argument, except when using the
// fast calling convention, when we need to make sure we do that only when
// we'll actually use a stack slot.
unsigned CurArgOffset;
Align Alignment;
auto ComputeArgOffset = [&]() {
/* Respect alignment of argument on the stack. */
Alignment =
CalculateStackSlotAlignment(ObjectVT, OrigVT, Flags, PtrByteSize);
ArgOffset = alignTo(ArgOffset, Alignment);
CurArgOffset = ArgOffset;
};
if (CallConv != CallingConv::Fast) {
ComputeArgOffset();
/* Compute GPR index associated with argument offset. */
GPR_idx = (ArgOffset - LinkageSize) / PtrByteSize;
GPR_idx = std::min(GPR_idx, Num_GPR_Regs);
}
// FIXME the codegen can be much improved in some cases.
// We do not have to keep everything in memory.
if (Flags.isByVal()) {
assert(Ins[ArgNo].isOrigArg() && "Byval arguments cannot be implicit");
if (CallConv == CallingConv::Fast)
ComputeArgOffset();
// ObjSize is the true size, ArgSize rounded up to multiple of registers.
ObjSize = Flags.getByValSize();
ArgSize = ((ObjSize + PtrByteSize - 1)/PtrByteSize) * PtrByteSize;
// Empty aggregate parameters do not take up registers. Examples:
// struct { } a;
// union { } b;
// int c[0];
// etc. However, we have to provide a place-holder in InVals, so
// pretend we have an 8-byte item at the current address for that
// purpose.
if (!ObjSize) {
int FI = MFI.CreateFixedObject(PtrByteSize, ArgOffset, true);
SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
InVals.push_back(FIN);
continue;
}
// Create a stack object covering all stack doublewords occupied
// by the argument. If the argument is (fully or partially) on
// the stack, or if the argument is fully in registers but the
// caller has allocated the parameter save anyway, we can refer
// directly to the caller's stack frame. Otherwise, create a
// local copy in our own frame.
int FI;
if (HasParameterArea ||
ArgSize + ArgOffset > LinkageSize + Num_GPR_Regs * PtrByteSize)
FI = MFI.CreateFixedObject(ArgSize, ArgOffset, false, true);
else
FI = MFI.CreateStackObject(ArgSize, Alignment, false);
SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
// Handle aggregates smaller than 8 bytes.
if (ObjSize < PtrByteSize) {
// The value of the object is its address, which differs from the
// address of the enclosing doubleword on big-endian systems.
SDValue Arg = FIN;
if (!isLittleEndian) {
SDValue ArgOff = DAG.getConstant(PtrByteSize - ObjSize, dl, PtrVT);
Arg = DAG.getNode(ISD::ADD, dl, ArgOff.getValueType(), Arg, ArgOff);
}
InVals.push_back(Arg);
if (GPR_idx != Num_GPR_Regs) {
Register VReg = MF.addLiveIn(GPR[GPR_idx++], &PPC::G8RCRegClass);
FuncInfo->addLiveInAttr(VReg, Flags);
SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
EVT ObjType = EVT::getIntegerVT(*DAG.getContext(), ObjSize * 8);
SDValue Store =
DAG.getTruncStore(Val.getValue(1), dl, Val, Arg,
MachinePointerInfo(&*FuncArg), ObjType);
MemOps.push_back(Store);
}
// Whether we copied from a register or not, advance the offset
// into the parameter save area by a full doubleword.
ArgOffset += PtrByteSize;
continue;
}
// The value of the object is its address, which is the address of
// its first stack doubleword.
InVals.push_back(FIN);
// Store whatever pieces of the object are in registers to memory.
for (unsigned j = 0; j < ArgSize; j += PtrByteSize) {
if (GPR_idx == Num_GPR_Regs)
break;
Register VReg = MF.addLiveIn(GPR[GPR_idx], &PPC::G8RCRegClass);
FuncInfo->addLiveInAttr(VReg, Flags);
SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
SDValue Addr = FIN;
if (j) {
SDValue Off = DAG.getConstant(j, dl, PtrVT);
Addr = DAG.getNode(ISD::ADD, dl, Off.getValueType(), Addr, Off);
}
SDValue Store = DAG.getStore(Val.getValue(1), dl, Val, Addr,
MachinePointerInfo(&*FuncArg, j));
MemOps.push_back(Store);
++GPR_idx;
}
ArgOffset += ArgSize;
continue;
}
switch (ObjectVT.getSimpleVT().SimpleTy) {
default: llvm_unreachable("Unhandled argument type!");
case MVT::i1:
case MVT::i32:
case MVT::i64:
if (Flags.isNest()) {
// The 'nest' parameter, if any, is passed in R11.
Register VReg = MF.addLiveIn(PPC::X11, &PPC::G8RCRegClass);
ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i64);
if (ObjectVT == MVT::i32 || ObjectVT == MVT::i1)
ArgVal = extendArgForPPC64(Flags, ObjectVT, DAG, ArgVal, dl);
break;
}
// These can be scalar arguments or elements of an integer array type
// passed directly. Clang may use those instead of "byval" aggregate
// types to avoid forcing arguments to memory unnecessarily.
if (GPR_idx != Num_GPR_Regs) {
Register VReg = MF.addLiveIn(GPR[GPR_idx++], &PPC::G8RCRegClass);
FuncInfo->addLiveInAttr(VReg, Flags);
ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i64);
if (ObjectVT == MVT::i32 || ObjectVT == MVT::i1)
// PPC64 passes i8, i16, and i32 values in i64 registers. Promote
// value to MVT::i64 and then truncate to the correct register size.
ArgVal = extendArgForPPC64(Flags, ObjectVT, DAG, ArgVal, dl);
} else {
if (CallConv == CallingConv::Fast)
ComputeArgOffset();
needsLoad = true;
ArgSize = PtrByteSize;
}
if (CallConv != CallingConv::Fast || needsLoad)
ArgOffset += 8;
break;
case MVT::f32:
case MVT::f64:
// These can be scalar arguments or elements of a float array type
// passed directly. The latter are used to implement ELFv2 homogenous
// float aggregates.
if (FPR_idx != Num_FPR_Regs) {
unsigned VReg;
if (ObjectVT == MVT::f32)
VReg = MF.addLiveIn(FPR[FPR_idx],
Subtarget.hasP8Vector()
? &PPC::VSSRCRegClass
: &PPC::F4RCRegClass);
else
VReg = MF.addLiveIn(FPR[FPR_idx], Subtarget.hasVSX()
? &PPC::VSFRCRegClass
: &PPC::F8RCRegClass);
ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, ObjectVT);
++FPR_idx;
} else if (GPR_idx != Num_GPR_Regs && CallConv != CallingConv::Fast) {
// FIXME: We may want to re-enable this for CallingConv::Fast on the P8
// once we support fp <-> gpr moves.
// This can only ever happen in the presence of f32 array types,
// since otherwise we never run out of FPRs before running out
// of GPRs.
Register VReg = MF.addLiveIn(GPR[GPR_idx++], &PPC::G8RCRegClass);
FuncInfo->addLiveInAttr(VReg, Flags);
ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i64);
if (ObjectVT == MVT::f32) {
if ((ArgOffset % PtrByteSize) == (isLittleEndian ? 4 : 0))
ArgVal = DAG.getNode(ISD::SRL, dl, MVT::i64, ArgVal,
DAG.getConstant(32, dl, MVT::i32));
ArgVal = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, ArgVal);
}
ArgVal = DAG.getNode(ISD::BITCAST, dl, ObjectVT, ArgVal);
} else {
if (CallConv == CallingConv::Fast)
ComputeArgOffset();
needsLoad = true;
}
// When passing an array of floats, the array occupies consecutive
// space in the argument area; only round up to the next doubleword
// at the end of the array. Otherwise, each float takes 8 bytes.
if (CallConv != CallingConv::Fast || needsLoad) {
ArgSize = Flags.isInConsecutiveRegs() ? ObjSize : PtrByteSize;
ArgOffset += ArgSize;
if (Flags.isInConsecutiveRegsLast())
ArgOffset = ((ArgOffset + PtrByteSize - 1)/PtrByteSize) * PtrByteSize;
}
break;
case MVT::v4f32:
case MVT::v4i32:
case MVT::v8i16:
case MVT::v16i8:
case MVT::v2f64:
case MVT::v2i64:
case MVT::v1i128:
case MVT::f128:
// These can be scalar arguments or elements of a vector array type
// passed directly. The latter are used to implement ELFv2 homogenous
// vector aggregates.
if (VR_idx != Num_VR_Regs) {
Register VReg = MF.addLiveIn(VR[VR_idx], &PPC::VRRCRegClass);
ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, ObjectVT);
++VR_idx;
} else {
if (CallConv == CallingConv::Fast)
ComputeArgOffset();
needsLoad = true;
}
if (CallConv != CallingConv::Fast || needsLoad)
ArgOffset += 16;
break;
}
// We need to load the argument to a virtual register if we determined
// above that we ran out of physical registers of the appropriate type.
if (needsLoad) {
if (ObjSize < ArgSize && !isLittleEndian)
CurArgOffset += ArgSize - ObjSize;
int FI = MFI.CreateFixedObject(ObjSize, CurArgOffset, isImmutable);
SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
ArgVal = DAG.getLoad(ObjectVT, dl, Chain, FIN, MachinePointerInfo());
}
InVals.push_back(ArgVal);
}
// Area that is at least reserved in the caller of this function.
unsigned MinReservedArea;
if (HasParameterArea)
MinReservedArea = std::max(ArgOffset, LinkageSize + 8 * PtrByteSize);
else
MinReservedArea = LinkageSize;
// Set the size that is at least reserved in caller of this function. Tail
// call optimized functions' reserved stack space needs to be aligned so that
// taking the difference between two stack areas will result in an aligned
// stack.
MinReservedArea =
EnsureStackAlignment(Subtarget.getFrameLowering(), MinReservedArea);
FuncInfo->setMinReservedArea(MinReservedArea);
// If the function takes variable number of arguments, make a frame index for
// the start of the first vararg value... for expansion of llvm.va_start.
// On ELFv2ABI spec, it writes:
// C programs that are intended to be *portable* across different compilers
// and architectures must use the header file <stdarg.h> to deal with variable
// argument lists.
if (isVarArg && MFI.hasVAStart()) {
int Depth = ArgOffset;
FuncInfo->setVarArgsFrameIndex(
MFI.CreateFixedObject(PtrByteSize, Depth, true));
SDValue FIN = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
// If this function is vararg, store any remaining integer argument regs
// to their spots on the stack so that they may be loaded by dereferencing
// the result of va_next.
for (GPR_idx = (ArgOffset - LinkageSize) / PtrByteSize;
GPR_idx < Num_GPR_Regs; ++GPR_idx) {
Register VReg = MF.addLiveIn(GPR[GPR_idx], &PPC::G8RCRegClass);
SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
SDValue Store =
DAG.getStore(Val.getValue(1), dl, Val, FIN, MachinePointerInfo());
MemOps.push_back(Store);
// Increment the address by four for the next argument to store
SDValue PtrOff = DAG.getConstant(PtrByteSize, dl, PtrVT);
FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
}
}
if (!MemOps.empty())
Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
return Chain;
}
/// CalculateTailCallSPDiff - Get the amount the stack pointer has to be
/// adjusted to accommodate the arguments for the tailcall.
static int CalculateTailCallSPDiff(SelectionDAG& DAG, bool isTailCall,
unsigned ParamSize) {
if (!isTailCall) return 0;
PPCFunctionInfo *FI = DAG.getMachineFunction().getInfo<PPCFunctionInfo>();
unsigned CallerMinReservedArea = FI->getMinReservedArea();
int SPDiff = (int)CallerMinReservedArea - (int)ParamSize;
// Remember only if the new adjustment is bigger.
if (SPDiff < FI->getTailCallSPDelta())
FI->setTailCallSPDelta(SPDiff);
return SPDiff;
}
static bool isFunctionGlobalAddress(SDValue Callee);
static bool callsShareTOCBase(const Function *Caller, SDValue Callee,
const TargetMachine &TM) {
// It does not make sense to call callsShareTOCBase() with a caller that
// is PC Relative since PC Relative callers do not have a TOC.
#ifndef NDEBUG
const PPCSubtarget *STICaller = &TM.getSubtarget<PPCSubtarget>(*Caller);
assert(!STICaller->isUsingPCRelativeCalls() &&
"PC Relative callers do not have a TOC and cannot share a TOC Base");
#endif
// Callee is either a GlobalAddress or an ExternalSymbol. ExternalSymbols
// don't have enough information to determine if the caller and callee share
// the same TOC base, so we have to pessimistically assume they don't for
// correctness.
GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee);
if (!G)
return false;
const GlobalValue *GV = G->getGlobal();
// If the callee is preemptable, then the static linker will use a plt-stub
// which saves the toc to the stack, and needs a nop after the call
// instruction to convert to a toc-restore.
if (!TM.shouldAssumeDSOLocal(*Caller->getParent(), GV))
return false;
// Functions with PC Relative enabled may clobber the TOC in the same DSO.
// We may need a TOC restore in the situation where the caller requires a
// valid TOC but the callee is PC Relative and does not.
const Function *F = dyn_cast<Function>(GV);
const GlobalAlias *Alias = dyn_cast<GlobalAlias>(GV);
// If we have an Alias we can try to get the function from there.
if (Alias) {
const GlobalObject *GlobalObj = Alias->getAliaseeObject();
F = dyn_cast<Function>(GlobalObj);
}
// If we still have no valid function pointer we do not have enough
// information to determine if the callee uses PC Relative calls so we must
// assume that it does.
if (!F)
return false;
// If the callee uses PC Relative we cannot guarantee that the callee won't
// clobber the TOC of the caller and so we must assume that the two
// functions do not share a TOC base.
const PPCSubtarget *STICallee = &TM.getSubtarget<PPCSubtarget>(*F);
if (STICallee->isUsingPCRelativeCalls())
return false;
// If the GV is not a strong definition then we need to assume it can be
// replaced by another function at link time. The function that replaces
// it may not share the same TOC as the caller since the callee may be
// replaced by a PC Relative version of the same function.
if (!GV->isStrongDefinitionForLinker())
return false;
// The medium and large code models are expected to provide a sufficiently
// large TOC to provide all data addressing needs of a module with a
// single TOC.
if (CodeModel::Medium == TM.getCodeModel() ||
CodeModel::Large == TM.getCodeModel())
return true;
// Any explicitly-specified sections and section prefixes must also match.
// Also, if we're using -ffunction-sections, then each function is always in
// a different section (the same is true for COMDAT functions).
if (TM.getFunctionSections() || GV->hasComdat() || Caller->hasComdat() ||
GV->getSection() != Caller->getSection())
return false;
if (const auto *F = dyn_cast<Function>(GV)) {
if (F->getSectionPrefix() != Caller->getSectionPrefix())
return false;
}
return true;
}
static bool
needStackSlotPassParameters(const PPCSubtarget &Subtarget,
const SmallVectorImpl<ISD::OutputArg> &Outs) {
assert(Subtarget.is64BitELFABI());
const unsigned PtrByteSize = 8;
const unsigned LinkageSize = Subtarget.getFrameLowering()->getLinkageSize();
static const MCPhysReg GPR[] = {
PPC::X3, PPC::X4, PPC::X5, PPC::X6,
PPC::X7, PPC::X8, PPC::X9, PPC::X10,
};
static const MCPhysReg VR[] = {
PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8,
PPC::V9, PPC::V10, PPC::V11, PPC::V12, PPC::V13
};
const unsigned NumGPRs = array_lengthof(GPR);
const unsigned NumFPRs = 13;
const unsigned NumVRs = array_lengthof(VR);
const unsigned ParamAreaSize = NumGPRs * PtrByteSize;
unsigned NumBytes = LinkageSize;
unsigned AvailableFPRs = NumFPRs;
unsigned AvailableVRs = NumVRs;
for (const ISD::OutputArg& Param : Outs) {
if (Param.Flags.isNest()) continue;
if (CalculateStackSlotUsed(Param.VT, Param.ArgVT, Param.Flags, PtrByteSize,
LinkageSize, ParamAreaSize, NumBytes,
AvailableFPRs, AvailableVRs))
return true;
}
return false;
}
static bool hasSameArgumentList(const Function *CallerFn, const CallBase &CB) {
if (CB.arg_size() != CallerFn->arg_size())
return false;
auto CalleeArgIter = CB.arg_begin();
auto CalleeArgEnd = CB.arg_end();
Function::const_arg_iterator CallerArgIter = CallerFn->arg_begin();
for (; CalleeArgIter != CalleeArgEnd; ++CalleeArgIter, ++CallerArgIter) {
const Value* CalleeArg = *CalleeArgIter;
const Value* CallerArg = &(*CallerArgIter);
if (CalleeArg == CallerArg)
continue;
// e.g. @caller([4 x i64] %a, [4 x i64] %b) {
// tail call @callee([4 x i64] undef, [4 x i64] %b)
// }
// 1st argument of callee is undef and has the same type as caller.
if (CalleeArg->getType() == CallerArg->getType() &&
isa<UndefValue>(CalleeArg))
continue;
return false;
}
return true;
}
// Returns true if TCO is possible between the callers and callees
// calling conventions.
static bool
areCallingConvEligibleForTCO_64SVR4(CallingConv::ID CallerCC,
CallingConv::ID CalleeCC) {
// Tail calls are possible with fastcc and ccc.
auto isTailCallableCC = [] (CallingConv::ID CC){
return CC == CallingConv::C || CC == CallingConv::Fast;
};
if (!isTailCallableCC(CallerCC) || !isTailCallableCC(CalleeCC))
return false;
// We can safely tail call both fastcc and ccc callees from a c calling
// convention caller. If the caller is fastcc, we may have less stack space
// than a non-fastcc caller with the same signature so disable tail-calls in
// that case.
return CallerCC == CallingConv::C || CallerCC == CalleeCC;
}
bool PPCTargetLowering::IsEligibleForTailCallOptimization_64SVR4(
SDValue Callee, CallingConv::ID CalleeCC, const CallBase *CB, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<ISD::InputArg> &Ins, SelectionDAG &DAG) const {
bool TailCallOpt = getTargetMachine().Options.GuaranteedTailCallOpt;
if (DisableSCO && !TailCallOpt) return false;
// Variadic argument functions are not supported.
if (isVarArg) return false;
auto &Caller = DAG.getMachineFunction().getFunction();
// Check that the calling conventions are compatible for tco.
if (!areCallingConvEligibleForTCO_64SVR4(Caller.getCallingConv(), CalleeCC))
return false;
// Caller contains any byval parameter is not supported.
if (any_of(Ins, [](const ISD::InputArg &IA) { return IA.Flags.isByVal(); }))
return false;
// Callee contains any byval parameter is not supported, too.
// Note: This is a quick work around, because in some cases, e.g.
// caller's stack size > callee's stack size, we are still able to apply
// sibling call optimization. For example, gcc is able to do SCO for caller1
// in the following example, but not for caller2.
// struct test {
// long int a;
// char ary[56];
// } gTest;
// __attribute__((noinline)) int callee(struct test v, struct test *b) {
// b->a = v.a;
// return 0;
// }
// void caller1(struct test a, struct test c, struct test *b) {
// callee(gTest, b); }
// void caller2(struct test *b) { callee(gTest, b); }
if (any_of(Outs, [](const ISD::OutputArg& OA) { return OA.Flags.isByVal(); }))
return false;
// If callee and caller use different calling conventions, we cannot pass
// parameters on stack since offsets for the parameter area may be different.
if (Caller.getCallingConv() != CalleeCC &&
needStackSlotPassParameters(Subtarget, Outs))
return false;
// All variants of 64-bit ELF ABIs without PC-Relative addressing require that
// the caller and callee share the same TOC for TCO/SCO. If the caller and
// callee potentially have different TOC bases then we cannot tail call since
// we need to restore the TOC pointer after the call.
// ref: https://bugzilla.mozilla.org/show_bug.cgi?id=973977
// We cannot guarantee this for indirect calls or calls to external functions.
// When PC-Relative addressing is used, the concept of the TOC is no longer
// applicable so this check is not required.
// Check first for indirect calls.
if (!Subtarget.isUsingPCRelativeCalls() &&
!isFunctionGlobalAddress(Callee) && !isa<ExternalSymbolSDNode>(Callee))
return false;
// Check if we share the TOC base.
if (!Subtarget.isUsingPCRelativeCalls() &&
!callsShareTOCBase(&Caller, Callee, getTargetMachine()))
return false;
// TCO allows altering callee ABI, so we don't have to check further.
if (CalleeCC == CallingConv::Fast && TailCallOpt)
return true;
if (DisableSCO) return false;
// If callee use the same argument list that caller is using, then we can
// apply SCO on this case. If it is not, then we need to check if callee needs
// stack for passing arguments.
// PC Relative tail calls may not have a CallBase.
// If there is no CallBase we cannot verify if we have the same argument
// list so assume that we don't have the same argument list.
if (CB && !hasSameArgumentList(&Caller, *CB) &&
needStackSlotPassParameters(Subtarget, Outs))
return false;
else if (!CB && needStackSlotPassParameters(Subtarget, Outs))
return false;
return true;
}
/// IsEligibleForTailCallOptimization - Check whether the call is eligible
/// for tail call optimization. Targets which want to do tail call
/// optimization should implement this function.
bool
PPCTargetLowering::IsEligibleForTailCallOptimization(SDValue Callee,
CallingConv::ID CalleeCC,
bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins,
SelectionDAG& DAG) const {
if (!getTargetMachine().Options.GuaranteedTailCallOpt)
return false;
// Variable argument functions are not supported.
if (isVarArg)
return false;
MachineFunction &MF = DAG.getMachineFunction();
CallingConv::ID CallerCC = MF.getFunction().getCallingConv();
if (CalleeCC == CallingConv::Fast && CallerCC == CalleeCC) {
// Functions containing by val parameters are not supported.
for (unsigned i = 0; i != Ins.size(); i++) {
ISD::ArgFlagsTy Flags = Ins[i].Flags;
if (Flags.isByVal()) return false;
}
// Non-PIC/GOT tail calls are supported.
if (getTargetMachine().getRelocationModel() != Reloc::PIC_)
return true;
// At the moment we can only do local tail calls (in same module, hidden
// or protected) if we are generating PIC.
if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee))
return G->getGlobal()->hasHiddenVisibility()
|| G->getGlobal()->hasProtectedVisibility();
}
return false;
}
/// isCallCompatibleAddress - Return the immediate to use if the specified
/// 32-bit value is representable in the immediate field of a BxA instruction.
static SDNode *isBLACompatibleAddress(SDValue Op, SelectionDAG &DAG) {
ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op);
if (!C) return nullptr;
int Addr = C->getZExtValue();
if ((Addr & 3) != 0 || // Low 2 bits are implicitly zero.
SignExtend32<26>(Addr) != Addr)
return nullptr; // Top 6 bits have to be sext of immediate.
return DAG
.getConstant(
(int)C->getZExtValue() >> 2, SDLoc(Op),
DAG.getTargetLoweringInfo().getPointerTy(DAG.getDataLayout()))
.getNode();
}
namespace {
struct TailCallArgumentInfo {
SDValue Arg;
SDValue FrameIdxOp;
int FrameIdx = 0;
TailCallArgumentInfo() = default;
};
} // end anonymous namespace
/// StoreTailCallArgumentsToStackSlot - Stores arguments to their stack slot.
static void StoreTailCallArgumentsToStackSlot(
SelectionDAG &DAG, SDValue Chain,
const SmallVectorImpl<TailCallArgumentInfo> &TailCallArgs,
SmallVectorImpl<SDValue> &MemOpChains, const SDLoc &dl) {
for (unsigned i = 0, e = TailCallArgs.size(); i != e; ++i) {
SDValue Arg = TailCallArgs[i].Arg;
SDValue FIN = TailCallArgs[i].FrameIdxOp;
int FI = TailCallArgs[i].FrameIdx;
// Store relative to framepointer.
MemOpChains.push_back(DAG.getStore(
Chain, dl, Arg, FIN,
MachinePointerInfo::getFixedStack(DAG.getMachineFunction(), FI)));
}
}
/// EmitTailCallStoreFPAndRetAddr - Move the frame pointer and return address to
/// the appropriate stack slot for the tail call optimized function call.
static SDValue EmitTailCallStoreFPAndRetAddr(SelectionDAG &DAG, SDValue Chain,
SDValue OldRetAddr, SDValue OldFP,
int SPDiff, const SDLoc &dl) {
if (SPDiff) {
// Calculate the new stack slot for the return address.
MachineFunction &MF = DAG.getMachineFunction();
const PPCSubtarget &Subtarget = MF.getSubtarget<PPCSubtarget>();
const PPCFrameLowering *FL = Subtarget.getFrameLowering();
bool isPPC64 = Subtarget.isPPC64();
int SlotSize = isPPC64 ? 8 : 4;
int NewRetAddrLoc = SPDiff + FL->getReturnSaveOffset();
int NewRetAddr = MF.getFrameInfo().CreateFixedObject(SlotSize,
NewRetAddrLoc, true);
EVT VT = isPPC64 ? MVT::i64 : MVT::i32;
SDValue NewRetAddrFrIdx = DAG.getFrameIndex(NewRetAddr, VT);
Chain = DAG.getStore(Chain, dl, OldRetAddr, NewRetAddrFrIdx,
MachinePointerInfo::getFixedStack(MF, NewRetAddr));
}
return Chain;
}
/// CalculateTailCallArgDest - Remember Argument for later processing. Calculate
/// the position of the argument.
static void
CalculateTailCallArgDest(SelectionDAG &DAG, MachineFunction &MF, bool isPPC64,
SDValue Arg, int SPDiff, unsigned ArgOffset,
SmallVectorImpl<TailCallArgumentInfo>& TailCallArguments) {
int Offset = ArgOffset + SPDiff;
uint32_t OpSize = (Arg.getValueSizeInBits() + 7) / 8;
int FI = MF.getFrameInfo().CreateFixedObject(OpSize, Offset, true);
EVT VT = isPPC64 ? MVT::i64 : MVT::i32;
SDValue FIN = DAG.getFrameIndex(FI, VT);
TailCallArgumentInfo Info;
Info.Arg = Arg;
Info.FrameIdxOp = FIN;
Info.FrameIdx = FI;
TailCallArguments.push_back(Info);
}
/// EmitTCFPAndRetAddrLoad - Emit load from frame pointer and return address
/// stack slot. Returns the chain as result and the loaded frame pointers in
/// LROpOut/FPOpout. Used when tail calling.
SDValue PPCTargetLowering::EmitTailCallLoadFPAndRetAddr(
SelectionDAG &DAG, int SPDiff, SDValue Chain, SDValue &LROpOut,
SDValue &FPOpOut, const SDLoc &dl) const {
if (SPDiff) {
// Load the LR and FP stack slot for later adjusting.
EVT VT = Subtarget.isPPC64() ? MVT::i64 : MVT::i32;
LROpOut = getReturnAddrFrameIndex(DAG);
LROpOut = DAG.getLoad(VT, dl, Chain, LROpOut, MachinePointerInfo());
Chain = SDValue(LROpOut.getNode(), 1);
}
return Chain;
}
/// CreateCopyOfByValArgument - Make a copy of an aggregate at address specified
/// by "Src" to address "Dst" of size "Size". Alignment information is
/// specified by the specific parameter attribute. The copy will be passed as
/// a byval function parameter.
/// Sometimes what we are copying is the end of a larger object, the part that
/// does not fit in registers.
static SDValue CreateCopyOfByValArgument(SDValue Src, SDValue Dst,
SDValue Chain, ISD::ArgFlagsTy Flags,
SelectionDAG &DAG, const SDLoc &dl) {
SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), dl, MVT::i32);
return DAG.getMemcpy(Chain, dl, Dst, Src, SizeNode,
Flags.getNonZeroByValAlign(), false, false, false,
MachinePointerInfo(), MachinePointerInfo());
}
/// LowerMemOpCallTo - Store the argument to the stack or remember it in case of
/// tail calls.
static void LowerMemOpCallTo(
SelectionDAG &DAG, MachineFunction &MF, SDValue Chain, SDValue Arg,
SDValue PtrOff, int SPDiff, unsigned ArgOffset, bool isPPC64,
bool isTailCall, bool isVector, SmallVectorImpl<SDValue> &MemOpChains,
SmallVectorImpl<TailCallArgumentInfo> &TailCallArguments, const SDLoc &dl) {
EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(DAG.getDataLayout());
if (!isTailCall) {
if (isVector) {
SDValue StackPtr;
if (isPPC64)
StackPtr = DAG.getRegister(PPC::X1, MVT::i64);
else
StackPtr = DAG.getRegister(PPC::R1, MVT::i32);
PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr,
DAG.getConstant(ArgOffset, dl, PtrVT));
}
MemOpChains.push_back(
DAG.getStore(Chain, dl, Arg, PtrOff, MachinePointerInfo()));
// Calculate and remember argument location.
} else CalculateTailCallArgDest(DAG, MF, isPPC64, Arg, SPDiff, ArgOffset,
TailCallArguments);
}
static void
PrepareTailCall(SelectionDAG &DAG, SDValue &InFlag, SDValue &Chain,
const SDLoc &dl, int SPDiff, unsigned NumBytes, SDValue LROp,
SDValue FPOp,
SmallVectorImpl<TailCallArgumentInfo> &TailCallArguments) {
// Emit a sequence of copyto/copyfrom virtual registers for arguments that
// might overwrite each other in case of tail call optimization.
SmallVector<SDValue, 8> MemOpChains2;
// Do not flag preceding copytoreg stuff together with the following stuff.
InFlag = SDValue();
StoreTailCallArgumentsToStackSlot(DAG, Chain, TailCallArguments,
MemOpChains2, dl);
if (!MemOpChains2.empty())
Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains2);
// Store the return address to the appropriate stack slot.
Chain = EmitTailCallStoreFPAndRetAddr(DAG, Chain, LROp, FPOp, SPDiff, dl);
// Emit callseq_end just before tailcall node.
Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(NumBytes, dl, true),
DAG.getIntPtrConstant(0, dl, true), InFlag, dl);
InFlag = Chain.getValue(1);
}
// Is this global address that of a function that can be called by name? (as
// opposed to something that must hold a descriptor for an indirect call).
static bool isFunctionGlobalAddress(SDValue Callee) {
if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
if (Callee.getOpcode() == ISD::GlobalTLSAddress ||
Callee.getOpcode() == ISD::TargetGlobalTLSAddress)
return false;
return G->getGlobal()->getValueType()->isFunctionTy();
}
return false;
}
SDValue PPCTargetLowering::LowerCallResult(
SDValue Chain, SDValue InFlag, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const {
SmallVector<CCValAssign, 16> RVLocs;
CCState CCRetInfo(CallConv, isVarArg, DAG.getMachineFunction(), RVLocs,
*DAG.getContext());
CCRetInfo.AnalyzeCallResult(
Ins, (Subtarget.isSVR4ABI() && CallConv == CallingConv::Cold)
? RetCC_PPC_Cold
: RetCC_PPC);
// Copy all of the result registers out of their specified physreg.
for (unsigned i = 0, e = RVLocs.size(); i != e; ++i) {
CCValAssign &VA = RVLocs[i];
assert(VA.isRegLoc() && "Can only return in registers!");
SDValue Val;
if (Subtarget.hasSPE() && VA.getLocVT() == MVT::f64) {
SDValue Lo = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(), MVT::i32,
InFlag);
Chain = Lo.getValue(1);
InFlag = Lo.getValue(2);
VA = RVLocs[++i]; // skip ahead to next loc
SDValue Hi = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(), MVT::i32,
InFlag);
Chain = Hi.getValue(1);
InFlag = Hi.getValue(2);
if (!Subtarget.isLittleEndian())
std::swap (Lo, Hi);
Val = DAG.getNode(PPCISD::BUILD_SPE64, dl, MVT::f64, Lo, Hi);
} else {
Val = DAG.getCopyFromReg(Chain, dl,
VA.getLocReg(), VA.getLocVT(), InFlag);
Chain = Val.getValue(1);
InFlag = Val.getValue(2);
}
switch (VA.getLocInfo()) {
default: llvm_unreachable("Unknown loc info!");
case CCValAssign::Full: break;
case CCValAssign::AExt:
Val = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), Val);
break;
case CCValAssign::ZExt:
Val = DAG.getNode(ISD::AssertZext, dl, VA.getLocVT(), Val,
DAG.getValueType(VA.getValVT()));
Val = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), Val);
break;
case CCValAssign::SExt:
Val = DAG.getNode(ISD::AssertSext, dl, VA.getLocVT(), Val,
DAG.getValueType(VA.getValVT()));
Val = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), Val);
break;
}
InVals.push_back(Val);
}
return Chain;
}
static bool isIndirectCall(const SDValue &Callee, SelectionDAG &DAG,
const PPCSubtarget &Subtarget, bool isPatchPoint) {
// PatchPoint calls are not indirect.
if (isPatchPoint)
return false;
if (isFunctionGlobalAddress(Callee) || isa<ExternalSymbolSDNode>(Callee))
return false;
// Darwin, and 32-bit ELF can use a BLA. The descriptor based ABIs can not
// becuase the immediate function pointer points to a descriptor instead of
// a function entry point. The ELFv2 ABI cannot use a BLA because the function
// pointer immediate points to the global entry point, while the BLA would
// need to jump to the local entry point (see rL211174).
if (!Subtarget.usesFunctionDescriptors() && !Subtarget.isELFv2ABI() &&
isBLACompatibleAddress(Callee, DAG))
return false;
return true;
}
// AIX and 64-bit ELF ABIs w/o PCRel require a TOC save/restore around calls.
static inline bool isTOCSaveRestoreRequired(const PPCSubtarget &Subtarget) {
return Subtarget.isAIXABI() ||
(Subtarget.is64BitELFABI() && !Subtarget.isUsingPCRelativeCalls());
}
static unsigned getCallOpcode(PPCTargetLowering::CallFlags CFlags,
const Function &Caller, const SDValue &Callee,
const PPCSubtarget &Subtarget,
const TargetMachine &TM,
bool IsStrictFPCall = false) {
if (CFlags.IsTailCall)
return PPCISD::TC_RETURN;
unsigned RetOpc = 0;
// This is a call through a function pointer.
if (CFlags.IsIndirect) {
// AIX and the 64-bit ELF ABIs need to maintain the TOC pointer accross
// indirect calls. The save of the caller's TOC pointer to the stack will be
// inserted into the DAG as part of call lowering. The restore of the TOC
// pointer is modeled by using a pseudo instruction for the call opcode that
// represents the 2 instruction sequence of an indirect branch and link,
// immediately followed by a load of the TOC pointer from the the stack save
// slot into gpr2. For 64-bit ELFv2 ABI with PCRel, do not restore the TOC
// as it is not saved or used.
RetOpc = isTOCSaveRestoreRequired(Subtarget) ? PPCISD::BCTRL_LOAD_TOC
: PPCISD::BCTRL;
} else if (Subtarget.isUsingPCRelativeCalls()) {
assert(Subtarget.is64BitELFABI() && "PC Relative is only on ELF ABI.");
RetOpc = PPCISD::CALL_NOTOC;
} else if (Subtarget.isAIXABI() || Subtarget.is64BitELFABI())
// The ABIs that maintain a TOC pointer accross calls need to have a nop
// immediately following the call instruction if the caller and callee may
// have different TOC bases. At link time if the linker determines the calls
// may not share a TOC base, the call is redirected to a trampoline inserted
// by the linker. The trampoline will (among other things) save the callers
// TOC pointer at an ABI designated offset in the linkage area and the
// linker will rewrite the nop to be a load of the TOC pointer from the
// linkage area into gpr2.
RetOpc = callsShareTOCBase(&Caller, Callee, TM) ? PPCISD::CALL
: PPCISD::CALL_NOP;
else
RetOpc = PPCISD::CALL;
if (IsStrictFPCall) {
switch (RetOpc) {
default:
llvm_unreachable("Unknown call opcode");
case PPCISD::BCTRL_LOAD_TOC:
RetOpc = PPCISD::BCTRL_LOAD_TOC_RM;
break;
case PPCISD::BCTRL:
RetOpc = PPCISD::BCTRL_RM;
break;
case PPCISD::CALL_NOTOC:
RetOpc = PPCISD::CALL_NOTOC_RM;
break;
case PPCISD::CALL:
RetOpc = PPCISD::CALL_RM;
break;
case PPCISD::CALL_NOP:
RetOpc = PPCISD::CALL_NOP_RM;
break;
}
}
return RetOpc;
}
static SDValue transformCallee(const SDValue &Callee, SelectionDAG &DAG,
const SDLoc &dl, const PPCSubtarget &Subtarget) {
if (!Subtarget.usesFunctionDescriptors() && !Subtarget.isELFv2ABI())
if (SDNode *Dest = isBLACompatibleAddress(Callee, DAG))
return SDValue(Dest, 0);
// Returns true if the callee is local, and false otherwise.
auto isLocalCallee = [&]() {
const GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee);
const Module *Mod = DAG.getMachineFunction().getFunction().getParent();
const GlobalValue *GV = G ? G->getGlobal() : nullptr;
return DAG.getTarget().shouldAssumeDSOLocal(*Mod, GV) &&
!isa_and_nonnull<GlobalIFunc>(GV);
};
// The PLT is only used in 32-bit ELF PIC mode. Attempting to use the PLT in
// a static relocation model causes some versions of GNU LD (2.17.50, at
// least) to force BSS-PLT, instead of secure-PLT, even if all objects are
// built with secure-PLT.
bool UsePlt =
Subtarget.is32BitELFABI() && !isLocalCallee() &&
Subtarget.getTargetMachine().getRelocationModel() == Reloc::PIC_;
const auto getAIXFuncEntryPointSymbolSDNode = [&](const GlobalValue *GV) {
const TargetMachine &TM = Subtarget.getTargetMachine();
const TargetLoweringObjectFile *TLOF = TM.getObjFileLowering();
MCSymbolXCOFF *S =
cast<MCSymbolXCOFF>(TLOF->getFunctionEntryPointSymbol(GV, TM));
MVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(DAG.getDataLayout());
return DAG.getMCSymbol(S, PtrVT);
};
if (isFunctionGlobalAddress(Callee)) {
const GlobalValue *GV = cast<GlobalAddressSDNode>(Callee)->getGlobal();
if (Subtarget.isAIXABI()) {
assert(!isa<GlobalIFunc>(GV) && "IFunc is not supported on AIX.");
return getAIXFuncEntryPointSymbolSDNode(GV);
}
return DAG.getTargetGlobalAddress(GV, dl, Callee.getValueType(), 0,
UsePlt ? PPCII::MO_PLT : 0);
}
if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
const char *SymName = S->getSymbol();
if (Subtarget.isAIXABI()) {
// If there exists a user-declared function whose name is the same as the
// ExternalSymbol's, then we pick up the user-declared version.
const Module *Mod = DAG.getMachineFunction().getFunction().getParent();
if (const Function *F =
dyn_cast_or_null<Function>(Mod->getNamedValue(SymName)))
return getAIXFuncEntryPointSymbolSDNode(F);
// On AIX, direct function calls reference the symbol for the function's
// entry point, which is named by prepending a "." before the function's
// C-linkage name. A Qualname is returned here because an external
// function entry point is a csect with XTY_ER property.
const auto getExternalFunctionEntryPointSymbol = [&](StringRef SymName) {
auto &Context = DAG.getMachineFunction().getMMI().getContext();
MCSectionXCOFF *Sec = Context.getXCOFFSection(
(Twine(".") + Twine(SymName)).str(), SectionKind::getMetadata(),
XCOFF::CsectProperties(XCOFF::XMC_PR, XCOFF::XTY_ER));
return Sec->getQualNameSymbol();
};
SymName = getExternalFunctionEntryPointSymbol(SymName)->getName().data();
}
return DAG.getTargetExternalSymbol(SymName, Callee.getValueType(),
UsePlt ? PPCII::MO_PLT : 0);
}
// No transformation needed.
assert(Callee.getNode() && "What no callee?");
return Callee;
}
static SDValue getOutputChainFromCallSeq(SDValue CallSeqStart) {
assert(CallSeqStart.getOpcode() == ISD::CALLSEQ_START &&
"Expected a CALLSEQ_STARTSDNode.");
// The last operand is the chain, except when the node has glue. If the node
// has glue, then the last operand is the glue, and the chain is the second
// last operand.
SDValue LastValue = CallSeqStart.getValue(CallSeqStart->getNumValues() - 1);
if (LastValue.getValueType() != MVT::Glue)
return LastValue;
return CallSeqStart.getValue(CallSeqStart->getNumValues() - 2);
}
// Creates the node that moves a functions address into the count register
// to prepare for an indirect call instruction.
static void prepareIndirectCall(SelectionDAG &DAG, SDValue &Callee,
SDValue &Glue, SDValue &Chain,
const SDLoc &dl) {
SDValue MTCTROps[] = {Chain, Callee, Glue};
EVT ReturnTypes[] = {MVT::Other, MVT::Glue};
Chain = DAG.getNode(PPCISD::MTCTR, dl, makeArrayRef(ReturnTypes, 2),
makeArrayRef(MTCTROps, Glue.getNode() ? 3 : 2));
// The glue is the second value produced.
Glue = Chain.getValue(1);
}
static void prepareDescriptorIndirectCall(SelectionDAG &DAG, SDValue &Callee,
SDValue &Glue, SDValue &Chain,
SDValue CallSeqStart,
const CallBase *CB, const SDLoc &dl,
bool hasNest,
const PPCSubtarget &Subtarget) {
// Function pointers in the 64-bit SVR4 ABI do not point to the function
// entry point, but to the function descriptor (the function entry point
// address is part of the function descriptor though).
// The function descriptor is a three doubleword structure with the
// following fields: function entry point, TOC base address and
// environment pointer.
// Thus for a call through a function pointer, the following actions need
// to be performed:
// 1. Save the TOC of the caller in the TOC save area of its stack
// frame (this is done in LowerCall_Darwin() or LowerCall_64SVR4()).
// 2. Load the address of the function entry point from the function
// descriptor.
// 3. Load the TOC of the callee from the function descriptor into r2.
// 4. Load the environment pointer from the function descriptor into
// r11.
// 5. Branch to the function entry point address.
// 6. On return of the callee, the TOC of the caller needs to be
// restored (this is done in FinishCall()).
//
// The loads are scheduled at the beginning of the call sequence, and the
// register copies are flagged together to ensure that no other
// operations can be scheduled in between. E.g. without flagging the
// copies together, a TOC access in the caller could be scheduled between
// the assignment of the callee TOC and the branch to the callee, which leads
// to incorrect code.
// Start by loading the function address from the descriptor.
SDValue LDChain = getOutputChainFromCallSeq(CallSeqStart);
auto MMOFlags = Subtarget.hasInvariantFunctionDescriptors()
? (MachineMemOperand::MODereferenceable |
MachineMemOperand::MOInvariant)
: MachineMemOperand::MONone;
MachinePointerInfo MPI(CB ? CB->getCalledOperand() : nullptr);
// Registers used in building the DAG.
const MCRegister EnvPtrReg = Subtarget.getEnvironmentPointerRegister();
const MCRegister TOCReg = Subtarget.getTOCPointerRegister();
// Offsets of descriptor members.
const unsigned TOCAnchorOffset = Subtarget.descriptorTOCAnchorOffset();
const unsigned EnvPtrOffset = Subtarget.descriptorEnvironmentPointerOffset();
const MVT RegVT = Subtarget.isPPC64() ? MVT::i64 : MVT::i32;
const unsigned Alignment = Subtarget.isPPC64() ? 8 : 4;
// One load for the functions entry point address.
SDValue LoadFuncPtr = DAG.getLoad(RegVT, dl, LDChain, Callee, MPI,
Alignment, MMOFlags);
// One for loading the TOC anchor for the module that contains the called
// function.
SDValue TOCOff = DAG.getIntPtrConstant(TOCAnchorOffset, dl);
SDValue AddTOC = DAG.getNode(ISD::ADD, dl, RegVT, Callee, TOCOff);
SDValue TOCPtr =
DAG.getLoad(RegVT, dl, LDChain, AddTOC,
MPI.getWithOffset(TOCAnchorOffset), Alignment, MMOFlags);
// One for loading the environment pointer.
SDValue PtrOff = DAG.getIntPtrConstant(EnvPtrOffset, dl);
SDValue AddPtr = DAG.getNode(ISD::ADD, dl, RegVT, Callee, PtrOff);
SDValue LoadEnvPtr =
DAG.getLoad(RegVT, dl, LDChain, AddPtr,
MPI.getWithOffset(EnvPtrOffset), Alignment, MMOFlags);
// Then copy the newly loaded TOC anchor to the TOC pointer.
SDValue TOCVal = DAG.getCopyToReg(Chain, dl, TOCReg, TOCPtr, Glue);
Chain = TOCVal.getValue(0);
Glue = TOCVal.getValue(1);
// If the function call has an explicit 'nest' parameter, it takes the
// place of the environment pointer.
assert((!hasNest || !Subtarget.isAIXABI()) &&
"Nest parameter is not supported on AIX.");
if (!hasNest) {
SDValue EnvVal = DAG.getCopyToReg(Chain, dl, EnvPtrReg, LoadEnvPtr, Glue);
Chain = EnvVal.getValue(0);
Glue = EnvVal.getValue(1);
}
// The rest of the indirect call sequence is the same as the non-descriptor
// DAG.
prepareIndirectCall(DAG, LoadFuncPtr, Glue, Chain, dl);
}
static void
buildCallOperands(SmallVectorImpl<SDValue> &Ops,
PPCTargetLowering::CallFlags CFlags, const SDLoc &dl,
SelectionDAG &DAG,
SmallVector<std::pair<unsigned, SDValue>, 8> &RegsToPass,
SDValue Glue, SDValue Chain, SDValue &Callee, int SPDiff,
const PPCSubtarget &Subtarget) {
const bool IsPPC64 = Subtarget.isPPC64();
// MVT for a general purpose register.
const MVT RegVT = IsPPC64 ? MVT::i64 : MVT::i32;
// First operand is always the chain.
Ops.push_back(Chain);
// If it's a direct call pass the callee as the second operand.
if (!CFlags.IsIndirect)
Ops.push_back(Callee);
else {
assert(!CFlags.IsPatchPoint && "Patch point calls are not indirect.");
// For the TOC based ABIs, we have saved the TOC pointer to the linkage area
// on the stack (this would have been done in `LowerCall_64SVR4` or
// `LowerCall_AIX`). The call instruction is a pseudo instruction that
// represents both the indirect branch and a load that restores the TOC
// pointer from the linkage area. The operand for the TOC restore is an add
// of the TOC save offset to the stack pointer. This must be the second
// operand: after the chain input but before any other variadic arguments.
// For 64-bit ELFv2 ABI with PCRel, do not restore the TOC as it is not
// saved or used.
if (isTOCSaveRestoreRequired(Subtarget)) {
const MCRegister StackPtrReg = Subtarget.getStackPointerRegister();
SDValue StackPtr = DAG.getRegister(StackPtrReg, RegVT);
unsigned TOCSaveOffset = Subtarget.getFrameLowering()->getTOCSaveOffset();
SDValue TOCOff = DAG.getIntPtrConstant(TOCSaveOffset, dl);
SDValue AddTOC = DAG.getNode(ISD::ADD, dl, RegVT, StackPtr, TOCOff);
Ops.push_back(AddTOC);
}
// Add the register used for the environment pointer.
if (Subtarget.usesFunctionDescriptors() && !CFlags.HasNest)
Ops.push_back(DAG.getRegister(Subtarget.getEnvironmentPointerRegister(),
RegVT));
// Add CTR register as callee so a bctr can be emitted later.
if (CFlags.IsTailCall)
Ops.push_back(DAG.getRegister(IsPPC64 ? PPC::CTR8 : PPC::CTR, RegVT));
}
// If this is a tail call add stack pointer delta.
if (CFlags.IsTailCall)
Ops.push_back(DAG.getConstant(SPDiff, dl, MVT::i32));
// Add argument registers to the end of the list so that they are known live
// into the call.
for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i)
Ops.push_back(DAG.getRegister(RegsToPass[i].first,
RegsToPass[i].second.getValueType()));
// We cannot add R2/X2 as an operand here for PATCHPOINT, because there is
// no way to mark dependencies as implicit here.
// We will add the R2/X2 dependency in EmitInstrWithCustomInserter.
if ((Subtarget.is64BitELFABI() || Subtarget.isAIXABI()) &&
!CFlags.IsPatchPoint && !Subtarget.isUsingPCRelativeCalls())
Ops.push_back(DAG.getRegister(Subtarget.getTOCPointerRegister(), RegVT));
// Add implicit use of CR bit 6 for 32-bit SVR4 vararg calls
if (CFlags.IsVarArg && Subtarget.is32BitELFABI())
Ops.push_back(DAG.getRegister(PPC::CR1EQ, MVT::i32));
// Add a register mask operand representing the call-preserved registers.
const TargetRegisterInfo *TRI = Subtarget.getRegisterInfo();
const uint32_t *Mask =
TRI->getCallPreservedMask(DAG.getMachineFunction(), CFlags.CallConv);
assert(Mask && "Missing call preserved mask for calling convention");
Ops.push_back(DAG.getRegisterMask(Mask));
// If the glue is valid, it is the last operand.
if (Glue.getNode())
Ops.push_back(Glue);
}
SDValue PPCTargetLowering::FinishCall(
CallFlags CFlags, const SDLoc &dl, SelectionDAG &DAG,
SmallVector<std::pair<unsigned, SDValue>, 8> &RegsToPass, SDValue Glue,
SDValue Chain, SDValue CallSeqStart, SDValue &Callee, int SPDiff,
unsigned NumBytes, const SmallVectorImpl<ISD::InputArg> &Ins,
SmallVectorImpl<SDValue> &InVals, const CallBase *CB) const {
if ((Subtarget.is64BitELFABI() && !Subtarget.isUsingPCRelativeCalls()) ||
Subtarget.isAIXABI())
setUsesTOCBasePtr(DAG);
unsigned CallOpc =
getCallOpcode(CFlags, DAG.getMachineFunction().getFunction(), Callee,
Subtarget, DAG.getTarget(), CB ? CB->isStrictFP() : false);
if (!CFlags.IsIndirect)
Callee = transformCallee(Callee, DAG, dl, Subtarget);
else if (Subtarget.usesFunctionDescriptors())
prepareDescriptorIndirectCall(DAG, Callee, Glue, Chain, CallSeqStart, CB,
dl, CFlags.HasNest, Subtarget);
else
prepareIndirectCall(DAG, Callee, Glue, Chain, dl);
// Build the operand list for the call instruction.
SmallVector<SDValue, 8> Ops;
buildCallOperands(Ops, CFlags, dl, DAG, RegsToPass, Glue, Chain, Callee,
SPDiff, Subtarget);
// Emit tail call.
if (CFlags.IsTailCall) {
// Indirect tail call when using PC Relative calls do not have the same
// constraints.
assert(((Callee.getOpcode() == ISD::Register &&
cast<RegisterSDNode>(Callee)->getReg() == PPC::CTR) ||
Callee.getOpcode() == ISD::TargetExternalSymbol ||
Callee.getOpcode() == ISD::TargetGlobalAddress ||
isa<ConstantSDNode>(Callee) ||
(CFlags.IsIndirect && Subtarget.isUsingPCRelativeCalls())) &&
"Expecting a global address, external symbol, absolute value, "
"register or an indirect tail call when PC Relative calls are "
"used.");
// PC Relative calls also use TC_RETURN as the way to mark tail calls.
assert(CallOpc == PPCISD::TC_RETURN &&
"Unexpected call opcode for a tail call.");
DAG.getMachineFunction().getFrameInfo().setHasTailCall();
return DAG.getNode(CallOpc, dl, MVT::Other, Ops);
}
std::array<EVT, 2> ReturnTypes = {{MVT::Other, MVT::Glue}};
Chain = DAG.getNode(CallOpc, dl, ReturnTypes, Ops);
DAG.addNoMergeSiteInfo(Chain.getNode(), CFlags.NoMerge);
Glue = Chain.getValue(1);
// When performing tail call optimization the callee pops its arguments off
// the stack. Account for this here so these bytes can be pushed back on in
// PPCFrameLowering::eliminateCallFramePseudoInstr.
int BytesCalleePops = (CFlags.CallConv == CallingConv::Fast &&
getTargetMachine().Options.GuaranteedTailCallOpt)
? NumBytes
: 0;
Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(NumBytes, dl, true),
DAG.getIntPtrConstant(BytesCalleePops, dl, true),
Glue, dl);
Glue = Chain.getValue(1);
return LowerCallResult(Chain, Glue, CFlags.CallConv, CFlags.IsVarArg, Ins, dl,
DAG, InVals);
}
SDValue
PPCTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
SmallVectorImpl<SDValue> &InVals) const {
SelectionDAG &DAG = CLI.DAG;
SDLoc &dl = CLI.DL;
SmallVectorImpl<ISD::OutputArg> &Outs = CLI.Outs;
SmallVectorImpl<SDValue> &OutVals = CLI.OutVals;
SmallVectorImpl<ISD::InputArg> &Ins = CLI.Ins;
SDValue Chain = CLI.Chain;
SDValue Callee = CLI.Callee;
bool &isTailCall = CLI.IsTailCall;
CallingConv::ID CallConv = CLI.CallConv;
bool isVarArg = CLI.IsVarArg;
bool isPatchPoint = CLI.IsPatchPoint;
const CallBase *CB = CLI.CB;
if (isTailCall) {
if (Subtarget.useLongCalls() && !(CB && CB->isMustTailCall()))
isTailCall = false;
else if (Subtarget.isSVR4ABI() && Subtarget.isPPC64())
isTailCall = IsEligibleForTailCallOptimization_64SVR4(
Callee, CallConv, CB, isVarArg, Outs, Ins, DAG);
else
isTailCall = IsEligibleForTailCallOptimization(Callee, CallConv, isVarArg,
Ins, DAG);
if (isTailCall) {
++NumTailCalls;
if (!getTargetMachine().Options.GuaranteedTailCallOpt)
++NumSiblingCalls;
// PC Relative calls no longer guarantee that the callee is a Global
// Address Node. The callee could be an indirect tail call in which
// case the SDValue for the callee could be a load (to load the address
// of a function pointer) or it may be a register copy (to move the
// address of the callee from a function parameter into a virtual
// register). It may also be an ExternalSymbolSDNode (ex memcopy).
assert((Subtarget.isUsingPCRelativeCalls() ||
isa<GlobalAddressSDNode>(Callee)) &&
"Callee should be an llvm::Function object.");
LLVM_DEBUG(dbgs() << "TCO caller: " << DAG.getMachineFunction().getName()
<< "\nTCO callee: ");
LLVM_DEBUG(Callee.dump());
}
}
if (!isTailCall && CB && CB->isMustTailCall())
report_fatal_error("failed to perform tail call elimination on a call "
"site marked musttail");
// When long calls (i.e. indirect calls) are always used, calls are always
// made via function pointer. If we have a function name, first translate it
// into a pointer.
if (Subtarget.useLongCalls() && isa<GlobalAddressSDNode>(Callee) &&
!isTailCall)
Callee = LowerGlobalAddress(Callee, DAG);
CallFlags CFlags(
CallConv, isTailCall, isVarArg, isPatchPoint,
isIndirectCall(Callee, DAG, Subtarget, isPatchPoint),
// hasNest
Subtarget.is64BitELFABI() &&
any_of(Outs, [](ISD::OutputArg Arg) { return Arg.Flags.isNest(); }),
CLI.NoMerge);
if (Subtarget.isAIXABI())
return LowerCall_AIX(Chain, Callee, CFlags, Outs, OutVals, Ins, dl, DAG,
InVals, CB);
assert(Subtarget.isSVR4ABI());
if (Subtarget.isPPC64())
return LowerCall_64SVR4(Chain, Callee, CFlags, Outs, OutVals, Ins, dl, DAG,
InVals, CB);
return LowerCall_32SVR4(Chain, Callee, CFlags, Outs, OutVals, Ins, dl, DAG,
InVals, CB);
}
SDValue PPCTargetLowering::LowerCall_32SVR4(
SDValue Chain, SDValue Callee, CallFlags CFlags,
const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals,
const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals,
const CallBase *CB) const {
// See PPCTargetLowering::LowerFormalArguments_32SVR4() for a description
// of the 32-bit SVR4 ABI stack frame layout.
const CallingConv::ID CallConv = CFlags.CallConv;
const bool IsVarArg = CFlags.IsVarArg;
const bool IsTailCall = CFlags.IsTailCall;
assert((CallConv == CallingConv::C ||
CallConv == CallingConv::Cold ||
CallConv == CallingConv::Fast) && "Unknown calling convention!");
const Align PtrAlign(4);
MachineFunction &MF = DAG.getMachineFunction();
// Mark this function as potentially containing a function that contains a
// tail call. As a consequence the frame pointer will be used for dynamicalloc
// and restoring the callers stack pointer in this functions epilog. This is
// done because by tail calling the called function might overwrite the value
// in this function's (MF) stack pointer stack slot 0(SP).
if (getTargetMachine().Options.GuaranteedTailCallOpt &&
CallConv == CallingConv::Fast)
MF.getInfo<PPCFunctionInfo>()->setHasFastCall();
// Count how many bytes are to be pushed on the stack, including the linkage
// area, parameter list area and the part of the local variable space which
// contains copies of aggregates which are passed by value.
// Assign locations to all of the outgoing arguments.
SmallVector<CCValAssign, 16> ArgLocs;
PPCCCState CCInfo(CallConv, IsVarArg, MF, ArgLocs, *DAG.getContext());
// Reserve space for the linkage area on the stack.
CCInfo.AllocateStack(Subtarget.getFrameLowering()->getLinkageSize(),
PtrAlign);
if (useSoftFloat())
CCInfo.PreAnalyzeCallOperands(Outs);
if (IsVarArg) {
// Handle fixed and variable vector arguments differently.
// Fixed vector arguments go into registers as long as registers are
// available. Variable vector arguments always go into memory.
unsigned NumArgs = Outs.size();
for (unsigned i = 0; i != NumArgs; ++i) {
MVT ArgVT = Outs[i].VT;
ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
bool Result;
if (Outs[i].IsFixed) {
Result = CC_PPC32_SVR4(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags,
CCInfo);
} else {
Result = CC_PPC32_SVR4_VarArg(i, ArgVT, ArgVT, CCValAssign::Full,
ArgFlags, CCInfo);
}
if (Result) {
#ifndef NDEBUG
errs() << "Call operand #" << i << " has unhandled type "
<< EVT(ArgVT).getEVTString() << "\n";
#endif
llvm_unreachable(nullptr);
}
}
} else {
// All arguments are treated the same.
CCInfo.AnalyzeCallOperands(Outs, CC_PPC32_SVR4);
}
CCInfo.clearWasPPCF128();
// Assign locations to all of the outgoing aggregate by value arguments.
SmallVector<CCValAssign, 16> ByValArgLocs;
CCState CCByValInfo(CallConv, IsVarArg, MF, ByValArgLocs, *DAG.getContext());
// Reserve stack space for the allocations in CCInfo.
CCByValInfo.AllocateStack(CCInfo.getNextStackOffset(), PtrAlign);
CCByValInfo.AnalyzeCallOperands(Outs, CC_PPC32_SVR4_ByVal);
// Size of the linkage area, parameter list area and the part of the local
// space variable where copies of aggregates which are passed by value are
// stored.
unsigned NumBytes = CCByValInfo.getNextStackOffset();
// Calculate by how many bytes the stack has to be adjusted in case of tail
// call optimization.
int SPDiff = CalculateTailCallSPDiff(DAG, IsTailCall, NumBytes);
// Adjust the stack pointer for the new arguments...
// These operations are automatically eliminated by the prolog/epilog pass
Chain = DAG.getCALLSEQ_START(Chain, NumBytes, 0, dl);
SDValue CallSeqStart = Chain;
// Load the return address and frame pointer so it can be moved somewhere else
// later.
SDValue LROp, FPOp;
Chain = EmitTailCallLoadFPAndRetAddr(DAG, SPDiff, Chain, LROp, FPOp, dl);
// Set up a copy of the stack pointer for use loading and storing any
// arguments that may not fit in the registers available for argument
// passing.
SDValue StackPtr = DAG.getRegister(PPC::R1, MVT::i32);
SmallVector<std::pair<unsigned, SDValue>, 8> RegsToPass;
SmallVector<TailCallArgumentInfo, 8> TailCallArguments;
SmallVector<SDValue, 8> MemOpChains;
bool seenFloatArg = false;
// Walk the register/memloc assignments, inserting copies/loads.
// i - Tracks the index into the list of registers allocated for the call
// RealArgIdx - Tracks the index into the list of actual function arguments
// j - Tracks the index into the list of byval arguments
for (unsigned i = 0, RealArgIdx = 0, j = 0, e = ArgLocs.size();
i != e;
++i, ++RealArgIdx) {
CCValAssign &VA = ArgLocs[i];
SDValue Arg = OutVals[RealArgIdx];
ISD::ArgFlagsTy Flags = Outs[RealArgIdx].Flags;
if (Flags.isByVal()) {
// Argument is an aggregate which is passed by value, thus we need to
// create a copy of it in the local variable space of the current stack
// frame (which is the stack frame of the caller) and pass the address of
// this copy to the callee.
assert((j < ByValArgLocs.size()) && "Index out of bounds!");
CCValAssign &ByValVA = ByValArgLocs[j++];
assert((VA.getValNo() == ByValVA.getValNo()) && "ValNo mismatch!");
// Memory reserved in the local variable space of the callers stack frame.
unsigned LocMemOffset = ByValVA.getLocMemOffset();
SDValue PtrOff = DAG.getIntPtrConstant(LocMemOffset, dl);
PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(MF.getDataLayout()),
StackPtr, PtrOff);
// Create a copy of the argument in the local area of the current
// stack frame.
SDValue MemcpyCall =
CreateCopyOfByValArgument(Arg, PtrOff,
CallSeqStart.getNode()->getOperand(0),
Flags, DAG, dl);
// This must go outside the CALLSEQ_START..END.
SDValue NewCallSeqStart = DAG.getCALLSEQ_START(MemcpyCall, NumBytes, 0,
SDLoc(MemcpyCall));
DAG.ReplaceAllUsesWith(CallSeqStart.getNode(),
NewCallSeqStart.getNode());
Chain = CallSeqStart = NewCallSeqStart;
// Pass the address of the aggregate copy on the stack either in a
// physical register or in the parameter list area of the current stack
// frame to the callee.
Arg = PtrOff;
}
// When useCRBits() is true, there can be i1 arguments.
// It is because getRegisterType(MVT::i1) => MVT::i1,
// and for other integer types getRegisterType() => MVT::i32.
// Extend i1 and ensure callee will get i32.
if (Arg.getValueType() == MVT::i1)
Arg = DAG.getNode(Flags.isSExt() ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND,
dl, MVT::i32, Arg);
if (VA.isRegLoc()) {
seenFloatArg |= VA.getLocVT().isFloatingPoint();
// Put argument in a physical register.
if (Subtarget.hasSPE() && Arg.getValueType() == MVT::f64) {
bool IsLE = Subtarget.isLittleEndian();
SDValue SVal = DAG.getNode(PPCISD::EXTRACT_SPE, dl, MVT::i32, Arg,
DAG.getIntPtrConstant(IsLE ? 0 : 1, dl));
RegsToPass.push_back(std::make_pair(VA.getLocReg(), SVal.getValue(0)));
SVal = DAG.getNode(PPCISD::EXTRACT_SPE, dl, MVT::i32, Arg,
DAG.getIntPtrConstant(IsLE ? 1 : 0, dl));
RegsToPass.push_back(std::make_pair(ArgLocs[++i].getLocReg(),
SVal.getValue(0)));
} else
RegsToPass.push_back(std::make_pair(VA.getLocReg(), Arg));
} else {
// Put argument in the parameter list area of the current stack frame.
assert(VA.isMemLoc());
unsigned LocMemOffset = VA.getLocMemOffset();
if (!IsTailCall) {
SDValue PtrOff = DAG.getIntPtrConstant(LocMemOffset, dl);
PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(MF.getDataLayout()),
StackPtr, PtrOff);
MemOpChains.push_back(
DAG.getStore(Chain, dl, Arg, PtrOff, MachinePointerInfo()));
} else {
// Calculate and remember argument location.
CalculateTailCallArgDest(DAG, MF, false, Arg, SPDiff, LocMemOffset,
TailCallArguments);
}
}
}
if (!MemOpChains.empty())
Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
// Build a sequence of copy-to-reg nodes chained together with token chain
// and flag operands which copy the outgoing args into the appropriate regs.
SDValue InFlag;
for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
RegsToPass[i].second, InFlag);
InFlag = Chain.getValue(1);
}
// Set CR bit 6 to true if this is a vararg call with floating args passed in
// registers.
if (IsVarArg) {
SDVTList VTs = DAG.getVTList(MVT::Other, MVT::Glue);
SDValue Ops[] = { Chain, InFlag };
Chain = DAG.getNode(seenFloatArg ? PPCISD::CR6SET : PPCISD::CR6UNSET,
dl, VTs, makeArrayRef(Ops, InFlag.getNode() ? 2 : 1));
InFlag = Chain.getValue(1);
}
if (IsTailCall)
PrepareTailCall(DAG, InFlag, Chain, dl, SPDiff, NumBytes, LROp, FPOp,
TailCallArguments);
return FinishCall(CFlags, dl, DAG, RegsToPass, InFlag, Chain, CallSeqStart,
Callee, SPDiff, NumBytes, Ins, InVals, CB);
}
// Copy an argument into memory, being careful to do this outside the
// call sequence for the call to which the argument belongs.
SDValue PPCTargetLowering::createMemcpyOutsideCallSeq(
SDValue Arg, SDValue PtrOff, SDValue CallSeqStart, ISD::ArgFlagsTy Flags,
SelectionDAG &DAG, const SDLoc &dl) const {
SDValue MemcpyCall = CreateCopyOfByValArgument(Arg, PtrOff,
CallSeqStart.getNode()->getOperand(0),
Flags, DAG, dl);
// The MEMCPY must go outside the CALLSEQ_START..END.
int64_t FrameSize = CallSeqStart.getConstantOperandVal(1);
SDValue NewCallSeqStart = DAG.getCALLSEQ_START(MemcpyCall, FrameSize, 0,
SDLoc(MemcpyCall));
DAG.ReplaceAllUsesWith(CallSeqStart.getNode(),
NewCallSeqStart.getNode());
return NewCallSeqStart;
}
SDValue PPCTargetLowering::LowerCall_64SVR4(
SDValue Chain, SDValue Callee, CallFlags CFlags,
const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals,
const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals,
const CallBase *CB) const {
bool isELFv2ABI = Subtarget.isELFv2ABI();
bool isLittleEndian = Subtarget.isLittleEndian();
unsigned NumOps = Outs.size();
bool IsSibCall = false;
bool IsFastCall = CFlags.CallConv == CallingConv::Fast;
EVT PtrVT = getPointerTy(DAG.getDataLayout());
unsigned PtrByteSize = 8;
MachineFunction &MF = DAG.getMachineFunction();
if (CFlags.IsTailCall && !getTargetMachine().Options.GuaranteedTailCallOpt)
IsSibCall = true;
// Mark this function as potentially containing a function that contains a
// tail call. As a consequence the frame pointer will be used for dynamicalloc
// and restoring the callers stack pointer in this functions epilog. This is
// done because by tail calling the called function might overwrite the value
// in this function's (MF) stack pointer stack slot 0(SP).
if (getTargetMachine().Options.GuaranteedTailCallOpt && IsFastCall)
MF.getInfo<PPCFunctionInfo>()->setHasFastCall();
assert(!(IsFastCall && CFlags.IsVarArg) &&
"fastcc not supported on varargs functions");
// Count how many bytes are to be pushed on the stack, including the linkage
// area, and parameter passing area. On ELFv1, the linkage area is 48 bytes
// reserved space for [SP][CR][LR][2 x unused][TOC]; on ELFv2, the linkage
// area is 32 bytes reserved space for [SP][CR][LR][TOC].
unsigned LinkageSize = Subtarget.getFrameLowering()->getLinkageSize();
unsigned NumBytes = LinkageSize;
unsigned GPR_idx = 0, FPR_idx = 0, VR_idx = 0;
static const MCPhysReg GPR[] = {
PPC::X3, PPC::X4, PPC::X5, PPC::X6,
PPC::X7, PPC::X8, PPC::X9, PPC::X10,
};
static const MCPhysReg VR[] = {
PPC::V2, PPC::V3, PPC::V4, PPC::V5, PPC::V6, PPC::V7, PPC::V8,
PPC::V9, PPC::V10, PPC::V11, PPC::V12, PPC::V13
};
const unsigned NumGPRs = array_lengthof(GPR);
const unsigned NumFPRs = useSoftFloat() ? 0 : 13;
const unsigned NumVRs = array_lengthof(VR);
// On ELFv2, we can avoid allocating the parameter area if all the arguments
// can be passed to the callee in registers.
// For the fast calling convention, there is another check below.
// Note: We should keep consistent with LowerFormalArguments_64SVR4()
bool HasParameterArea = !isELFv2ABI || CFlags.IsVarArg || IsFastCall;
if (!HasParameterArea) {
unsigned ParamAreaSize = NumGPRs * PtrByteSize;
unsigned AvailableFPRs = NumFPRs;
unsigned AvailableVRs = NumVRs;
unsigned NumBytesTmp = NumBytes;
for (unsigned i = 0; i != NumOps; ++i) {
if (Outs[i].Flags.isNest()) continue;
if (CalculateStackSlotUsed(Outs[i].VT, Outs[i].ArgVT, Outs[i].Flags,
PtrByteSize, LinkageSize, ParamAreaSize,
NumBytesTmp, AvailableFPRs, AvailableVRs))
HasParameterArea = true;
}
}
// When using the fast calling convention, we don't provide backing for
// arguments that will be in registers.
unsigned NumGPRsUsed = 0, NumFPRsUsed = 0, NumVRsUsed = 0;
// Avoid allocating parameter area for fastcc functions if all the arguments
// can be passed in the registers.
if (IsFastCall)
HasParameterArea = false;
// Add up all the space actually used.
for (unsigned i = 0; i != NumOps; ++i) {
ISD::ArgFlagsTy Flags = Outs[i].Flags;
EVT ArgVT = Outs[i].VT;
EVT OrigVT = Outs[i].ArgVT;
if (Flags.isNest())
continue;
if (IsFastCall) {
if (Flags.isByVal()) {
NumGPRsUsed += (Flags.getByValSize()+7)/8;
if (NumGPRsUsed > NumGPRs)
HasParameterArea = true;
} else {
switch (ArgVT.getSimpleVT().SimpleTy) {
default: llvm_unreachable("Unexpected ValueType for argument!");
case MVT::i1:
case MVT::i32:
case MVT::i64:
if (++NumGPRsUsed <= NumGPRs)
continue;
break;
case MVT::v4i32:
case MVT::v8i16:
case MVT::v16i8:
case MVT::v2f64:
case MVT::v2i64:
case MVT::v1i128:
case MVT::f128:
if (++NumVRsUsed <= NumVRs)
continue;
break;
case MVT::v4f32:
if (++NumVRsUsed <= NumVRs)
continue;
break;
case MVT::f32:
case MVT::f64:
if (++NumFPRsUsed <= NumFPRs)
continue;
break;
}
HasParameterArea = true;
}
}
/* Respect alignment of argument on the stack. */
auto Alignement =
CalculateStackSlotAlignment(ArgVT, OrigVT, Flags, PtrByteSize);
NumBytes = alignTo(NumBytes, Alignement);
NumBytes += CalculateStackSlotSize(ArgVT, Flags, PtrByteSize);
if (Flags.isInConsecutiveRegsLast())
NumBytes = ((NumBytes + PtrByteSize - 1)/PtrByteSize) * PtrByteSize;
}
unsigned NumBytesActuallyUsed = NumBytes;
// In the old ELFv1 ABI,
// the prolog code of the callee may store up to 8 GPR argument registers to
// the stack, allowing va_start to index over them in memory if its varargs.
// Because we cannot tell if this is needed on the caller side, we have to
// conservatively assume that it is needed. As such, make sure we have at
// least enough stack space for the caller to store the 8 GPRs.
// In the ELFv2 ABI, we allocate the parameter area iff a callee
// really requires memory operands, e.g. a vararg function.
if (HasParameterArea)
NumBytes = std::max(NumBytes, LinkageSize + 8 * PtrByteSize);
else
NumBytes = LinkageSize;
// Tail call needs the stack to be aligned.
if (getTargetMachine().Options.GuaranteedTailCallOpt && IsFastCall)
NumBytes = EnsureStackAlignment(Subtarget.getFrameLowering(), NumBytes);
int SPDiff = 0;
// Calculate by how many bytes the stack has to be adjusted in case of tail
// call optimization.
if (!IsSibCall)
SPDiff = CalculateTailCallSPDiff(DAG, CFlags.IsTailCall, NumBytes);
// To protect arguments on the stack from being clobbered in a tail call,
// force all the loads to happen before doing any other lowering.
if (CFlags.IsTailCall)
Chain = DAG.getStackArgumentTokenFactor(Chain);
// Adjust the stack pointer for the new arguments...
// These operations are automatically eliminated by the prolog/epilog pass
if (!IsSibCall)
Chain = DAG.getCALLSEQ_START(Chain, NumBytes, 0, dl);
SDValue CallSeqStart = Chain;
// Load the return address and frame pointer so it can be move somewhere else
// later.
SDValue LROp, FPOp;
Chain = EmitTailCallLoadFPAndRetAddr(DAG, SPDiff, Chain, LROp, FPOp, dl);
// Set up a copy of the stack pointer for use loading and storing any
// arguments that may not fit in the registers available for argument
// passing.
SDValue StackPtr = DAG.getRegister(PPC::X1, MVT::i64);
// Figure out which arguments are going to go in registers, and which in
// memory. Also, if this is a vararg function, floating point operations
// must be stored to our stack, and loaded into integer regs as well, if
// any integer regs are available for argument passing.
unsigned ArgOffset = LinkageSize;
SmallVector<std::pair<unsigned, SDValue>, 8> RegsToPass;
SmallVector<TailCallArgumentInfo, 8> TailCallArguments;
SmallVector<SDValue, 8> MemOpChains;
for (unsigned i = 0; i != NumOps; ++i) {
SDValue Arg = OutVals[i];
ISD::ArgFlagsTy Flags = Outs[i].Flags;
EVT ArgVT = Outs[i].VT;
EVT OrigVT = Outs[i].ArgVT;
// PtrOff will be used to store the current argument to the stack if a
// register cannot be found for it.
SDValue PtrOff;
// We re-align the argument offset for each argument, except when using the
// fast calling convention, when we need to make sure we do that only when
// we'll actually use a stack slot.
auto ComputePtrOff = [&]() {
/* Respect alignment of argument on the stack. */
auto Alignment =
CalculateStackSlotAlignment(ArgVT, OrigVT, Flags, PtrByteSize);
ArgOffset = alignTo(ArgOffset, Alignment);
PtrOff = DAG.getConstant(ArgOffset, dl, StackPtr.getValueType());
PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr, PtrOff);
};
if (!IsFastCall) {
ComputePtrOff();
/* Compute GPR index associated with argument offset. */
GPR_idx = (ArgOffset - LinkageSize) / PtrByteSize;
GPR_idx = std::min(GPR_idx, NumGPRs);
}
// Promote integers to 64-bit values.
if (Arg.getValueType() == MVT::i32 || Arg.getValueType() == MVT::i1) {
// FIXME: Should this use ANY_EXTEND if neither sext nor zext?
unsigned ExtOp = Flags.isSExt() ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND;
Arg = DAG.getNode(ExtOp, dl, MVT::i64, Arg);
}
// FIXME memcpy is used way more than necessary. Correctness first.
// Note: "by value" is code for passing a structure by value, not
// basic types.
if (Flags.isByVal()) {
// Note: Size includes alignment padding, so
// struct x { short a; char b; }
// will have Size = 4. With #pragma pack(1), it will have Size = 3.
// These are the proper values we need for right-justifying the
// aggregate in a parameter register.
unsigned Size = Flags.getByValSize();
// An empty aggregate parameter takes up no storage and no
// registers.
if (Size == 0)
continue;
if (IsFastCall)
ComputePtrOff();
// All aggregates smaller than 8 bytes must be passed right-justified.
if (Size==1 || Size==2 || Size==4) {
EVT VT = (Size==1) ? MVT::i8 : ((Size==2) ? MVT::i16 : MVT::i32);
if (GPR_idx != NumGPRs) {
SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, PtrVT, Chain, Arg,
MachinePointerInfo(), VT);
MemOpChains.push_back(Load.getValue(1));
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], Load));
ArgOffset += PtrByteSize;
continue;
}
}
if (GPR_idx == NumGPRs && Size < 8) {
SDValue AddPtr = PtrOff;
if (!isLittleEndian) {
SDValue Const = DAG.getConstant(PtrByteSize - Size, dl,
PtrOff.getValueType());
AddPtr = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, Const);
}
Chain = CallSeqStart = createMemcpyOutsideCallSeq(Arg, AddPtr,
CallSeqStart,
Flags, DAG, dl);
ArgOffset += PtrByteSize;
continue;
}
// Copy the object to parameter save area if it can not be entirely passed
// by registers.
// FIXME: we only need to copy the parts which need to be passed in
// parameter save area. For the parts passed by registers, we don't need
// to copy them to the stack although we need to allocate space for them
// in parameter save area.
if ((NumGPRs - GPR_idx) * PtrByteSize < Size)
Chain = CallSeqStart = createMemcpyOutsideCallSeq(Arg, PtrOff,
CallSeqStart,
Flags, DAG, dl);
// When a register is available, pass a small aggregate right-justified.
if (Size < 8 && GPR_idx != NumGPRs) {
// The easiest way to get this right-justified in a register
// is to copy the structure into the rightmost portion of a
// local variable slot, then load the whole slot into the
// register.
// FIXME: The memcpy seems to produce pretty awful code for
// small aggregates, particularly for packed ones.
// FIXME: It would be preferable to use the slot in the
// parameter save area instead of a new local variable.
SDValue AddPtr = PtrOff;
if (!isLittleEndian) {
SDValue Const = DAG.getConstant(8 - Size, dl, PtrOff.getValueType());
AddPtr = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, Const);
}
Chain = CallSeqStart = createMemcpyOutsideCallSeq(Arg, AddPtr,
CallSeqStart,
Flags, DAG, dl);
// Load the slot into the register.
SDValue Load =
DAG.getLoad(PtrVT, dl, Chain, PtrOff, MachinePointerInfo());
MemOpChains.push_back(Load.getValue(1));
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], Load));
// Done with this argument.
ArgOffset += PtrByteSize;
continue;
}
// For aggregates larger than PtrByteSize, copy the pieces of the
// object that fit into registers from the parameter save area.
for (unsigned j=0; j<Size; j+=PtrByteSize) {
SDValue Const = DAG.getConstant(j, dl, PtrOff.getValueType());
SDValue AddArg = DAG.getNode(ISD::ADD, dl, PtrVT, Arg, Const);
if (GPR_idx != NumGPRs) {
SDValue Load =
DAG.getLoad(PtrVT, dl, Chain, AddArg, MachinePointerInfo());
MemOpChains.push_back(Load.getValue(1));
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], Load));
ArgOffset += PtrByteSize;
} else {
ArgOffset += ((Size - j + PtrByteSize-1)/PtrByteSize)*PtrByteSize;
break;
}
}
continue;
}
switch (Arg.getSimpleValueType().SimpleTy) {
default: llvm_unreachable("Unexpected ValueType for argument!");
case MVT::i1:
case MVT::i32:
case MVT::i64:
if (Flags.isNest()) {
// The 'nest' parameter, if any, is passed in R11.
RegsToPass.push_back(std::make_pair(PPC::X11, Arg));
break;
}
// These can be scalar arguments or elements of an integer array type
// passed directly. Clang may use those instead of "byval" aggregate
// types to avoid forcing arguments to memory unnecessarily.
if (GPR_idx != NumGPRs) {
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], Arg));
} else {
if (IsFastCall)
ComputePtrOff();
assert(HasParameterArea &&
"Parameter area must exist to pass an argument in memory.");
LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset,
true, CFlags.IsTailCall, false, MemOpChains,
TailCallArguments, dl);
if (IsFastCall)
ArgOffset += PtrByteSize;
}
if (!IsFastCall)
ArgOffset += PtrByteSize;
break;
case MVT::f32:
case MVT::f64: {
// These can be scalar arguments or elements of a float array type
// passed directly. The latter are used to implement ELFv2 homogenous
// float aggregates.
// Named arguments go into FPRs first, and once they overflow, the
// remaining arguments go into GPRs and then the parameter save area.
// Unnamed arguments for vararg functions always go to GPRs and
// then the parameter save area. For now, put all arguments to vararg
// routines always in both locations (FPR *and* GPR or stack slot).
bool NeedGPROrStack = CFlags.IsVarArg || FPR_idx == NumFPRs;
bool NeededLoad = false;
// First load the argument into the next available FPR.
if (FPR_idx != NumFPRs)
RegsToPass.push_back(std::make_pair(FPR[FPR_idx++], Arg));
// Next, load the argument into GPR or stack slot if needed.
if (!NeedGPROrStack)
;
else if (GPR_idx != NumGPRs && !IsFastCall) {
// FIXME: We may want to re-enable this for CallingConv::Fast on the P8
// once we support fp <-> gpr moves.
// In the non-vararg case, this can only ever happen in the
// presence of f32 array types, since otherwise we never run
// out of FPRs before running out of GPRs.
SDValue ArgVal;
// Double values are always passed in a single GPR.
if (Arg.getValueType() != MVT::f32) {
ArgVal = DAG.getNode(ISD::BITCAST, dl, MVT::i64, Arg);
// Non-array float values are extended and passed in a GPR.
} else if (!Flags.isInConsecutiveRegs()) {
ArgVal = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Arg);
ArgVal = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i64, ArgVal);
// If we have an array of floats, we collect every odd element
// together with its predecessor into one GPR.
} else if (ArgOffset % PtrByteSize != 0) {
SDValue Lo, Hi;
Lo = DAG.getNode(ISD::BITCAST, dl, MVT::i32, OutVals[i - 1]);
Hi = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Arg);
if (!isLittleEndian)
std::swap(Lo, Hi);
ArgVal = DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Lo, Hi);
// The final element, if even, goes into the first half of a GPR.
} else if (Flags.isInConsecutiveRegsLast()) {
ArgVal = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Arg);
ArgVal = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i64, ArgVal);
if (!isLittleEndian)
ArgVal = DAG.getNode(ISD::SHL, dl, MVT::i64, ArgVal,
DAG.getConstant(32, dl, MVT::i32));
// Non-final even elements are skipped; they will be handled
// together the with subsequent argument on the next go-around.
} else
ArgVal = SDValue();
if (ArgVal.getNode())
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], ArgVal));
} else {
if (IsFastCall)
ComputePtrOff();
// Single-precision floating-point values are mapped to the
// second (rightmost) word of the stack doubleword.
if (Arg.getValueType() == MVT::f32 &&
!isLittleEndian && !Flags.isInConsecutiveRegs()) {
SDValue ConstFour = DAG.getConstant(4, dl, PtrOff.getValueType());
PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, ConstFour);
}
assert(HasParameterArea &&
"Parameter area must exist to pass an argument in memory.");
LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset,
true, CFlags.IsTailCall, false, MemOpChains,
TailCallArguments, dl);
NeededLoad = true;
}
// When passing an array of floats, the array occupies consecutive
// space in the argument area; only round up to the next doubleword
// at the end of the array. Otherwise, each float takes 8 bytes.
if (!IsFastCall || NeededLoad) {
ArgOffset += (Arg.getValueType() == MVT::f32 &&
Flags.isInConsecutiveRegs()) ? 4 : 8;
if (Flags.isInConsecutiveRegsLast())
ArgOffset = ((ArgOffset + PtrByteSize - 1)/PtrByteSize) * PtrByteSize;
}
break;
}
case MVT::v4f32:
case MVT::v4i32:
case MVT::v8i16:
case MVT::v16i8:
case MVT::v2f64:
case MVT::v2i64:
case MVT::v1i128:
case MVT::f128:
// These can be scalar arguments or elements of a vector array type
// passed directly. The latter are used to implement ELFv2 homogenous
// vector aggregates.
// For a varargs call, named arguments go into VRs or on the stack as
// usual; unnamed arguments always go to the stack or the corresponding
// GPRs when within range. For now, we always put the value in both
// locations (or even all three).
if (CFlags.IsVarArg) {
assert(HasParameterArea &&
"Parameter area must exist if we have a varargs call.");
// We could elide this store in the case where the object fits
// entirely in R registers. Maybe later.
SDValue Store =
DAG.getStore(Chain, dl, Arg, PtrOff, MachinePointerInfo());
MemOpChains.push_back(Store);
if (VR_idx != NumVRs) {
SDValue Load =
DAG.getLoad(MVT::v4f32, dl, Store, PtrOff, MachinePointerInfo());
MemOpChains.push_back(Load.getValue(1));
RegsToPass.push_back(std::make_pair(VR[VR_idx++], Load));
}
ArgOffset += 16;
for (unsigned i=0; i<16; i+=PtrByteSize) {
if (GPR_idx == NumGPRs)
break;
SDValue Ix = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff,
DAG.getConstant(i, dl, PtrVT));
SDValue Load =
DAG.getLoad(PtrVT, dl, Store, Ix, MachinePointerInfo());
MemOpChains.push_back(Load.getValue(1));
RegsToPass.push_back(std::make_pair(GPR[GPR_idx++], Load));
}
break;
}
// Non-varargs Altivec params go into VRs or on the stack.
if (VR_idx != NumVRs) {
RegsToPass.push_back(std::make_pair(VR[VR_idx++], Arg));
} else {
if (IsFastCall)
ComputePtrOff();
assert(HasParameterArea &&
"Parameter area must exist to pass an argument in memory.");
LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset,
true, CFlags.IsTailCall, true, MemOpChains,
TailCallArguments, dl);
if (IsFastCall)
ArgOffset += 16;
}
if (!IsFastCall)
ArgOffset += 16;
break;
}
}
assert((!HasParameterArea || NumBytesActuallyUsed == ArgOffset) &&
"mismatch in size of parameter area");
(void)NumBytesActuallyUsed;
if (!MemOpChains.empty())
Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
// Check if this is an indirect call (MTCTR/BCTRL).
// See prepareDescriptorIndirectCall and buildCallOperands for more
// information about calls through function pointers in the 64-bit SVR4 ABI.
if (CFlags.IsIndirect) {
// For 64-bit ELFv2 ABI with PCRel, do not save the TOC of the
// caller in the TOC save area.
if (isTOCSaveRestoreRequired(Subtarget)) {
assert(!CFlags.IsTailCall && "Indirect tails calls not supported");
// Load r2 into a virtual register and store it to the TOC save area.
setUsesTOCBasePtr(DAG);
SDValue Val = DAG.getCopyFromReg(Chain, dl, PPC::X2, MVT::i64);
// TOC save area offset.
unsigned TOCSaveOffset = Subtarget.getFrameLowering()->getTOCSaveOffset();
SDValue PtrOff = DAG.getIntPtrConstant(TOCSaveOffset, dl);
SDValue AddPtr = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr, PtrOff);
Chain = DAG.getStore(Val.getValue(1), dl, Val, AddPtr,
MachinePointerInfo::getStack(
DAG.getMachineFunction(), TOCSaveOffset));
}
// In the ELFv2 ABI, R12 must contain the address of an indirect callee.
// This does not mean the MTCTR instruction must use R12; it's easier
// to model this as an extra parameter, so do that.
if (isELFv2ABI && !CFlags.IsPatchPoint)
RegsToPass.push_back(std::make_pair((unsigned)PPC::X12, Callee));
}
// Build a sequence of copy-to-reg nodes chained together with token chain
// and flag operands which copy the outgoing args into the appropriate regs.
SDValue InFlag;
for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
RegsToPass[i].second, InFlag);
InFlag = Chain.getValue(1);
}
if (CFlags.IsTailCall && !IsSibCall)
PrepareTailCall(DAG, InFlag, Chain, dl, SPDiff, NumBytes, LROp, FPOp,
TailCallArguments);
return FinishCall(CFlags, dl, DAG, RegsToPass, InFlag, Chain, CallSeqStart,
Callee, SPDiff, NumBytes, Ins, InVals, CB);
}
// Returns true when the shadow of a general purpose argument register
// in the parameter save area is aligned to at least 'RequiredAlign'.
static bool isGPRShadowAligned(MCPhysReg Reg, Align RequiredAlign) {
assert(RequiredAlign.value() <= 16 &&
"Required alignment greater than stack alignment.");
switch (Reg) {
default:
report_fatal_error("called on invalid register.");
case PPC::R5:
case PPC::R9:
case PPC::X3:
case PPC::X5:
case PPC::X7:
case PPC::X9:
// These registers are 16 byte aligned which is the most strict aligment
// we can support.
return true;
case PPC::R3:
case PPC::R7:
case PPC::X4:
case PPC::X6:
case PPC::X8:
case PPC::X10:
// The shadow of these registers in the PSA is 8 byte aligned.
return RequiredAlign <= 8;
case PPC::R4:
case PPC::R6:
case PPC::R8:
case PPC::R10:
return RequiredAlign <= 4;
}
}
static bool CC_AIX(unsigned ValNo, MVT ValVT, MVT LocVT,
CCValAssign::LocInfo LocInfo, ISD::ArgFlagsTy ArgFlags,
CCState &S) {
AIXCCState &State = static_cast<AIXCCState &>(S);
const PPCSubtarget &Subtarget = static_cast<const PPCSubtarget &>(
State.getMachineFunction().getSubtarget());
const bool IsPPC64 = Subtarget.isPPC64();
const Align PtrAlign = IsPPC64 ? Align(8) : Align(4);
const MVT RegVT = IsPPC64 ? MVT::i64 : MVT::i32;
if (ValVT == MVT::f128)
report_fatal_error("f128 is unimplemented on AIX.");
if (ArgFlags.isNest())
report_fatal_error("Nest arguments are unimplemented.");
static const MCPhysReg GPR_32[] = {// 32-bit registers.
PPC::R3, PPC::R4, PPC::R5, PPC::R6,
PPC::R7, PPC::R8, PPC::R9, PPC::R10};
static const MCPhysReg GPR_64[] = {// 64-bit registers.
PPC::X3, PPC::X4, PPC::X5, PPC::X6,
PPC::X7, PPC::X8, PPC::X9, PPC::X10};
static const MCPhysReg VR[] = {// Vector registers.
PPC::V2, PPC::V3, PPC::V4, PPC::V5,
PPC::V6, PPC::V7, PPC::V8, PPC::V9,
PPC::V10, PPC::V11, PPC::V12, PPC::V13};
if (ArgFlags.isByVal()) {
if (ArgFlags.getNonZeroByValAlign() > PtrAlign)
report_fatal_error("Pass-by-value arguments with alignment greater than "
"register width are not supported.");
const unsigned ByValSize = ArgFlags.getByValSize();
// An empty aggregate parameter takes up no storage and no registers,
// but needs a MemLoc for a stack slot for the formal arguments side.
if (ByValSize == 0) {
State.addLoc(CCValAssign::getMem(ValNo, MVT::INVALID_SIMPLE_VALUE_TYPE,
State.getNextStackOffset(), RegVT,
LocInfo));
return false;
}
const unsigned StackSize = alignTo(ByValSize, PtrAlign);
unsigned Offset = State.AllocateStack(StackSize, PtrAlign);
for (const unsigned E = Offset + StackSize; Offset < E;
Offset += PtrAlign.value()) {
if (unsigned Reg = State.AllocateReg(IsPPC64 ? GPR_64 : GPR_32))
State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, RegVT, LocInfo));
else {
State.addLoc(CCValAssign::getMem(ValNo, MVT::INVALID_SIMPLE_VALUE_TYPE,
Offset, MVT::INVALID_SIMPLE_VALUE_TYPE,
LocInfo));
break;
}
}
return false;
}
// Arguments always reserve parameter save area.
switch (ValVT.SimpleTy) {
default:
report_fatal_error("Unhandled value type for argument.");
case MVT::i64:
// i64 arguments should have been split to i32 for PPC32.
assert(IsPPC64 && "PPC32 should have split i64 values.");
LLVM_FALLTHROUGH;
case MVT::i1:
case MVT::i32: {
const unsigned Offset = State.AllocateStack(PtrAlign.value(), PtrAlign);
// AIX integer arguments are always passed in register width.
if (ValVT.getFixedSizeInBits() < RegVT.getFixedSizeInBits())
LocInfo = ArgFlags.isSExt() ? CCValAssign::LocInfo::SExt
: CCValAssign::LocInfo::ZExt;
if (unsigned Reg = State.AllocateReg(IsPPC64 ? GPR_64 : GPR_32))
State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, RegVT, LocInfo));
else
State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset, RegVT, LocInfo));
return false;
}
case MVT::f32:
case MVT::f64: {
// Parameter save area (PSA) is reserved even if the float passes in fpr.
const unsigned StoreSize = LocVT.getStoreSize();
// Floats are always 4-byte aligned in the PSA on AIX.
// This includes f64 in 64-bit mode for ABI compatibility.
const unsigned Offset =
State.AllocateStack(IsPPC64 ? 8 : StoreSize, Align(4));
unsigned FReg = State.AllocateReg(FPR);
if (FReg)
State.addLoc(CCValAssign::getReg(ValNo, ValVT, FReg, LocVT, LocInfo));
// Reserve and initialize GPRs or initialize the PSA as required.
for (unsigned I = 0; I < StoreSize; I += PtrAlign.value()) {
if (unsigned Reg = State.AllocateReg(IsPPC64 ? GPR_64 : GPR_32)) {
assert(FReg && "An FPR should be available when a GPR is reserved.");
if (State.isVarArg()) {
// Successfully reserved GPRs are only initialized for vararg calls.
// Custom handling is required for:
// f64 in PPC32 needs to be split into 2 GPRs.
// f32 in PPC64 needs to occupy only lower 32 bits of 64-bit GPR.
State.addLoc(
CCValAssign::getCustomReg(ValNo, ValVT, Reg, RegVT, LocInfo));
}
} else {
// If there are insufficient GPRs, the PSA needs to be initialized.
// Initialization occurs even if an FPR was initialized for
// compatibility with the AIX XL compiler. The full memory for the
// argument will be initialized even if a prior word is saved in GPR.
// A custom memLoc is used when the argument also passes in FPR so
// that the callee handling can skip over it easily.
State.addLoc(
FReg ? CCValAssign::getCustomMem(ValNo, ValVT, Offset, LocVT,
LocInfo)
: CCValAssign::getMem(ValNo, ValVT, Offset, LocVT, LocInfo));
break;
}
}
return false;
}
case MVT::v4f32:
case MVT::v4i32:
case MVT::v8i16:
case MVT::v16i8:
case MVT::v2i64:
case MVT::v2f64:
case MVT::v1i128: {
const unsigned VecSize = 16;
const Align VecAlign(VecSize);
if (!State.isVarArg()) {
// If there are vector registers remaining we don't consume any stack
// space.
if (unsigned VReg = State.AllocateReg(VR)) {
State.addLoc(CCValAssign::getReg(ValNo, ValVT, VReg, LocVT, LocInfo));
return false;
}
// Vectors passed on the stack do not shadow GPRs or FPRs even though they
// might be allocated in the portion of the PSA that is shadowed by the
// GPRs.
const unsigned Offset = State.AllocateStack(VecSize, VecAlign);
State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset, LocVT, LocInfo));
return false;
}
const unsigned PtrSize = IsPPC64 ? 8 : 4;
ArrayRef<MCPhysReg> GPRs = IsPPC64 ? GPR_64 : GPR_32;
unsigned NextRegIndex = State.getFirstUnallocated(GPRs);
// Burn any underaligned registers and their shadowed stack space until
// we reach the required alignment.
while (NextRegIndex != GPRs.size() &&
!isGPRShadowAligned(GPRs[NextRegIndex], VecAlign)) {
// Shadow allocate register and its stack shadow.
unsigned Reg = State.AllocateReg(GPRs);
State.AllocateStack(PtrSize, PtrAlign);
assert(Reg && "Allocating register unexpectedly failed.");
(void)Reg;
NextRegIndex = State.getFirstUnallocated(GPRs);
}
// Vectors that are passed as fixed arguments are handled differently.
// They are passed in VRs if any are available (unlike arguments passed
// through ellipses) and shadow GPRs (unlike arguments to non-vaarg
// functions)
if (State.isFixed(ValNo)) {
if (unsigned VReg = State.AllocateReg(VR)) {
State.addLoc(CCValAssign::getReg(ValNo, ValVT, VReg, LocVT, LocInfo));
// Shadow allocate GPRs and stack space even though we pass in a VR.
for (unsigned I = 0; I != VecSize; I += PtrSize)
State.AllocateReg(GPRs);
State.AllocateStack(VecSize, VecAlign);
return false;
}
// No vector registers remain so pass on the stack.
const unsigned Offset = State.AllocateStack(VecSize, VecAlign);
State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset, LocVT, LocInfo));
return false;
}
// If all GPRS are consumed then we pass the argument fully on the stack.
if (NextRegIndex == GPRs.size()) {
const unsigned Offset = State.AllocateStack(VecSize, VecAlign);
State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset, LocVT, LocInfo));
return false;
}
// Corner case for 32-bit codegen. We have 2 registers to pass the first
// half of the argument, and then need to pass the remaining half on the
// stack.
if (GPRs[NextRegIndex] == PPC::R9) {
const unsigned Offset = State.AllocateStack(VecSize, VecAlign);
State.addLoc(
CCValAssign::getCustomMem(ValNo, ValVT, Offset, LocVT, LocInfo));
const unsigned FirstReg = State.AllocateReg(PPC::R9);
const unsigned SecondReg = State.AllocateReg(PPC::R10);
assert(FirstReg && SecondReg &&
"Allocating R9 or R10 unexpectedly failed.");
State.addLoc(
CCValAssign::getCustomReg(ValNo, ValVT, FirstReg, RegVT, LocInfo));
State.addLoc(
CCValAssign::getCustomReg(ValNo, ValVT, SecondReg, RegVT, LocInfo));
return false;
}
// We have enough GPRs to fully pass the vector argument, and we have
// already consumed any underaligned registers. Start with the custom
// MemLoc and then the custom RegLocs.
const unsigned Offset = State.AllocateStack(VecSize, VecAlign);
State.addLoc(
CCValAssign::getCustomMem(ValNo, ValVT, Offset, LocVT, LocInfo));
for (unsigned I = 0; I != VecSize; I += PtrSize) {
const unsigned Reg = State.AllocateReg(GPRs);
assert(Reg && "Failed to allocated register for vararg vector argument");
State.addLoc(
CCValAssign::getCustomReg(ValNo, ValVT, Reg, RegVT, LocInfo));
}
return false;
}
}
return true;
}
// So far, this function is only used by LowerFormalArguments_AIX()
static const TargetRegisterClass *getRegClassForSVT(MVT::SimpleValueType SVT,
bool IsPPC64,
bool HasP8Vector,
bool HasVSX) {
assert((IsPPC64 || SVT != MVT::i64) &&
"i64 should have been split for 32-bit codegen.");
switch (SVT) {
default:
report_fatal_error("Unexpected value type for formal argument");
case MVT::i1:
case MVT::i32:
case MVT::i64:
return IsPPC64 ? &PPC::G8RCRegClass : &PPC::GPRCRegClass;
case MVT::f32:
return HasP8Vector ? &PPC::VSSRCRegClass : &PPC::F4RCRegClass;
case MVT::f64:
return HasVSX ? &PPC::VSFRCRegClass : &PPC::F8RCRegClass;
case MVT::v4f32:
case MVT::v4i32:
case MVT::v8i16:
case MVT::v16i8:
case MVT::v2i64:
case MVT::v2f64:
case MVT::v1i128:
return &PPC::VRRCRegClass;
}
}
static SDValue truncateScalarIntegerArg(ISD::ArgFlagsTy Flags, EVT ValVT,
SelectionDAG &DAG, SDValue ArgValue,
MVT LocVT, const SDLoc &dl) {
assert(ValVT.isScalarInteger() && LocVT.isScalarInteger());
assert(ValVT.getFixedSizeInBits() < LocVT.getFixedSizeInBits());
if (Flags.isSExt())
ArgValue = DAG.getNode(ISD::AssertSext, dl, LocVT, ArgValue,
DAG.getValueType(ValVT));
else if (Flags.isZExt())
ArgValue = DAG.getNode(ISD::AssertZext, dl, LocVT, ArgValue,
DAG.getValueType(ValVT));
return DAG.getNode(ISD::TRUNCATE, dl, ValVT, ArgValue);
}
static unsigned mapArgRegToOffsetAIX(unsigned Reg, const PPCFrameLowering *FL) {
const unsigned LASize = FL->getLinkageSize();
if (PPC::GPRCRegClass.contains(Reg)) {
assert(Reg >= PPC::R3 && Reg <= PPC::R10 &&
"Reg must be a valid argument register!");
return LASize + 4 * (Reg - PPC::R3);
}
if (PPC::G8RCRegClass.contains(Reg)) {
assert(Reg >= PPC::X3 && Reg <= PPC::X10 &&
"Reg must be a valid argument register!");
return LASize + 8 * (Reg - PPC::X3);
}
llvm_unreachable("Only general purpose registers expected.");
}
// AIX ABI Stack Frame Layout:
//
// Low Memory +--------------------------------------------+
// SP +---> | Back chain | ---+
// | +--------------------------------------------+ |
// | | Saved Condition Register | |
// | +--------------------------------------------+ |
// | | Saved Linkage Register | |
// | +--------------------------------------------+ | Linkage Area
// | | Reserved for compilers | |
// | +--------------------------------------------+ |
// | | Reserved for binders | |
// | +--------------------------------------------+ |
// | | Saved TOC pointer | ---+
// | +--------------------------------------------+
// | | Parameter save area |
// | +--------------------------------------------+
// | | Alloca space |
// | +--------------------------------------------+
// | | Local variable space |
// | +--------------------------------------------+
// | | Float/int conversion temporary |
// | +--------------------------------------------+
// | | Save area for AltiVec registers |
// | +--------------------------------------------+
// | | AltiVec alignment padding |
// | +--------------------------------------------+
// | | Save area for VRSAVE register |
// | +--------------------------------------------+
// | | Save area for General Purpose registers |
// | +--------------------------------------------+
// | | Save area for Floating Point registers |
// | +--------------------------------------------+
// +---- | Back chain |
// High Memory +--------------------------------------------+
//
// Specifications:
// AIX 7.2 Assembler Language Reference
// Subroutine linkage convention
SDValue PPCTargetLowering::LowerFormalArguments_AIX(
SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const {
assert((CallConv == CallingConv::C || CallConv == CallingConv::Cold ||
CallConv == CallingConv::Fast) &&
"Unexpected calling convention!");
if (getTargetMachine().Options.GuaranteedTailCallOpt)
report_fatal_error("Tail call support is unimplemented on AIX.");
if (useSoftFloat())
report_fatal_error("Soft float support is unimplemented on AIX.");
const PPCSubtarget &Subtarget =
static_cast<const PPCSubtarget &>(DAG.getSubtarget());
const bool IsPPC64 = Subtarget.isPPC64();
const unsigned PtrByteSize = IsPPC64 ? 8 : 4;
// Assign locations to all of the incoming arguments.
SmallVector<CCValAssign, 16> ArgLocs;
MachineFunction &MF = DAG.getMachineFunction();
MachineFrameInfo &MFI = MF.getFrameInfo();
PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
AIXCCState CCInfo(CallConv, isVarArg, MF, ArgLocs, *DAG.getContext());
const EVT PtrVT = getPointerTy(MF.getDataLayout());
// Reserve space for the linkage area on the stack.
const unsigned LinkageSize = Subtarget.getFrameLowering()->getLinkageSize();
CCInfo.AllocateStack(LinkageSize, Align(PtrByteSize));
CCInfo.AnalyzeFormalArguments(Ins, CC_AIX);
SmallVector<SDValue, 8> MemOps;
for (size_t I = 0, End = ArgLocs.size(); I != End; /* No increment here */) {
CCValAssign &VA = ArgLocs[I++];
MVT LocVT = VA.getLocVT();
MVT ValVT = VA.getValVT();
ISD::ArgFlagsTy Flags = Ins[VA.getValNo()].Flags;
// For compatibility with the AIX XL compiler, the float args in the
// parameter save area are initialized even if the argument is available
// in register. The caller is required to initialize both the register
// and memory, however, the callee can choose to expect it in either.
// The memloc is dismissed here because the argument is retrieved from
// the register.
if (VA.isMemLoc() && VA.needsCustom() && ValVT.isFloatingPoint())
continue;
auto HandleMemLoc = [&]() {
const unsigned LocSize = LocVT.getStoreSize();
const unsigned ValSize = ValVT.getStoreSize();
assert((ValSize <= LocSize) &&
"Object size is larger than size of MemLoc");
int CurArgOffset = VA.getLocMemOffset();
// Objects are right-justified because AIX is big-endian.
if (LocSize > ValSize)
CurArgOffset += LocSize - ValSize;
// Potential tail calls could cause overwriting of argument stack slots.
const bool IsImmutable =
!(getTargetMachine().Options.GuaranteedTailCallOpt &&
(CallConv == CallingConv::Fast));
int FI = MFI.CreateFixedObject(ValSize, CurArgOffset, IsImmutable);
SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
SDValue ArgValue =
DAG.getLoad(ValVT, dl, Chain, FIN, MachinePointerInfo());
InVals.push_back(ArgValue);
};
// Vector arguments to VaArg functions are passed both on the stack, and
// in any available GPRs. Load the value from the stack and add the GPRs
// as live ins.
if (VA.isMemLoc() && VA.needsCustom()) {
assert(ValVT.isVector() && "Unexpected Custom MemLoc type.");
assert(isVarArg && "Only use custom memloc for vararg.");
// ValNo of the custom MemLoc, so we can compare it to the ValNo of the
// matching custom RegLocs.
const unsigned OriginalValNo = VA.getValNo();
(void)OriginalValNo;
auto HandleCustomVecRegLoc = [&]() {
assert(I != End && ArgLocs[I].isRegLoc() && ArgLocs[I].needsCustom() &&
"Missing custom RegLoc.");
VA = ArgLocs[I++];
assert(VA.getValVT().isVector() &&
"Unexpected Val type for custom RegLoc.");
assert(VA.getValNo() == OriginalValNo &&
"ValNo mismatch between custom MemLoc and RegLoc.");
MVT::SimpleValueType SVT = VA.getLocVT().SimpleTy;
MF.addLiveIn(VA.getLocReg(),
getRegClassForSVT(SVT, IsPPC64, Subtarget.hasP8Vector(),
Subtarget.hasVSX()));
};
HandleMemLoc();
// In 64-bit there will be exactly 2 custom RegLocs that follow, and in
// in 32-bit there will be 2 custom RegLocs if we are passing in R9 and
// R10.
HandleCustomVecRegLoc();
HandleCustomVecRegLoc();
// If we are targeting 32-bit, there might be 2 extra custom RegLocs if
// we passed the vector in R5, R6, R7 and R8.
if (I != End && ArgLocs[I].isRegLoc() && ArgLocs[I].needsCustom()) {
assert(!IsPPC64 &&
"Only 2 custom RegLocs expected for 64-bit codegen.");
HandleCustomVecRegLoc();
HandleCustomVecRegLoc();
}
continue;
}
if (VA.isRegLoc()) {
if (VA.getValVT().isScalarInteger())
FuncInfo->appendParameterType(PPCFunctionInfo::FixedType);
else if (VA.getValVT().isFloatingPoint() && !VA.getValVT().isVector()) {
switch (VA.getValVT().SimpleTy) {
default:
report_fatal_error("Unhandled value type for argument.");
case MVT::f32:
FuncInfo->appendParameterType(PPCFunctionInfo::ShortFloatingPoint);
break;
case MVT::f64:
FuncInfo->appendParameterType(PPCFunctionInfo::LongFloatingPoint);
break;
}
} else if (VA.getValVT().isVector()) {
switch (VA.getValVT().SimpleTy) {
default:
report_fatal_error("Unhandled value type for argument.");
case MVT::v16i8:
FuncInfo->appendParameterType(PPCFunctionInfo::VectorChar);
break;
case MVT::v8i16:
FuncInfo->appendParameterType(PPCFunctionInfo::VectorShort);
break;
case MVT::v4i32:
case MVT::v2i64:
case MVT::v1i128:
FuncInfo->appendParameterType(PPCFunctionInfo::VectorInt);
break;
case MVT::v4f32:
case MVT::v2f64:
FuncInfo->appendParameterType(PPCFunctionInfo::VectorFloat);
break;
}
}
}
if (Flags.isByVal() && VA.isMemLoc()) {
const unsigned Size =
alignTo(Flags.getByValSize() ? Flags.getByValSize() : PtrByteSize,
PtrByteSize);
const int FI = MF.getFrameInfo().CreateFixedObject(
Size, VA.getLocMemOffset(), /* IsImmutable */ false,
/* IsAliased */ true);
SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
InVals.push_back(FIN);
continue;
}
if (Flags.isByVal()) {
assert(VA.isRegLoc() && "MemLocs should already be handled.");
const MCPhysReg ArgReg = VA.getLocReg();
const PPCFrameLowering *FL = Subtarget.getFrameLowering();
if (Flags.getNonZeroByValAlign() > PtrByteSize)
report_fatal_error("Over aligned byvals not supported yet.");
const unsigned StackSize = alignTo(Flags.getByValSize(), PtrByteSize);
const int FI = MF.getFrameInfo().CreateFixedObject(
StackSize, mapArgRegToOffsetAIX(ArgReg, FL), /* IsImmutable */ false,
/* IsAliased */ true);
SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
InVals.push_back(FIN);
// Add live ins for all the RegLocs for the same ByVal.
const TargetRegisterClass *RegClass =
IsPPC64 ? &PPC::G8RCRegClass : &PPC::GPRCRegClass;
auto HandleRegLoc = [&, RegClass, LocVT](const MCPhysReg PhysReg,
unsigned Offset) {
const Register VReg = MF.addLiveIn(PhysReg, RegClass);
// Since the callers side has left justified the aggregate in the
// register, we can simply store the entire register into the stack
// slot.
SDValue CopyFrom = DAG.getCopyFromReg(Chain, dl, VReg, LocVT);
// The store to the fixedstack object is needed becuase accessing a
// field of the ByVal will use a gep and load. Ideally we will optimize
// to extracting the value from the register directly, and elide the
// stores when the arguments address is not taken, but that will need to
// be future work.
SDValue Store = DAG.getStore(
CopyFrom.getValue(1), dl, CopyFrom,
DAG.getObjectPtrOffset(dl, FIN, TypeSize::Fixed(Offset)),
MachinePointerInfo::getFixedStack(MF, FI, Offset));
MemOps.push_back(Store);
};
unsigned Offset = 0;
HandleRegLoc(VA.getLocReg(), Offset);
Offset += PtrByteSize;
for (; Offset != StackSize && ArgLocs[I].isRegLoc();
Offset += PtrByteSize) {
assert(ArgLocs[I].getValNo() == VA.getValNo() &&
"RegLocs should be for ByVal argument.");
const CCValAssign RL = ArgLocs[I++];
HandleRegLoc(RL.getLocReg(), Offset);
FuncInfo->appendParameterType(PPCFunctionInfo::FixedType);
}
if (Offset != StackSize) {
assert(ArgLocs[I].getValNo() == VA.getValNo() &&
"Expected MemLoc for remaining bytes.");
assert(ArgLocs[I].isMemLoc() && "Expected MemLoc for remaining bytes.");
// Consume the MemLoc.The InVal has already been emitted, so nothing
// more needs to be done.
++I;
}
continue;
}
if (VA.isRegLoc() && !VA.needsCustom()) {
MVT::SimpleValueType SVT = ValVT.SimpleTy;
Register VReg =
MF.addLiveIn(VA.getLocReg(),
getRegClassForSVT(SVT, IsPPC64, Subtarget.hasP8Vector(),
Subtarget.hasVSX()));
SDValue ArgValue = DAG.getCopyFromReg(Chain, dl, VReg, LocVT);
if (ValVT.isScalarInteger() &&
(ValVT.getFixedSizeInBits() < LocVT.getFixedSizeInBits())) {
ArgValue =
truncateScalarIntegerArg(Flags, ValVT, DAG, ArgValue, LocVT, dl);
}
InVals.push_back(ArgValue);
continue;
}
if (VA.isMemLoc()) {
HandleMemLoc();
continue;
}
}
// On AIX a minimum of 8 words is saved to the parameter save area.
const unsigned MinParameterSaveArea = 8 * PtrByteSize;
// Area that is at least reserved in the caller of this function.
unsigned CallerReservedArea =
std::max(CCInfo.getNextStackOffset(), LinkageSize + MinParameterSaveArea);
// Set the size that is at least reserved in caller of this function. Tail
// call optimized function's reserved stack space needs to be aligned so
// that taking the difference between two stack areas will result in an
// aligned stack.
CallerReservedArea =
EnsureStackAlignment(Subtarget.getFrameLowering(), CallerReservedArea);
FuncInfo->setMinReservedArea(CallerReservedArea);
if (isVarArg) {
FuncInfo->setVarArgsFrameIndex(
MFI.CreateFixedObject(PtrByteSize, CCInfo.getNextStackOffset(), true));
SDValue FIN = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
static const MCPhysReg GPR_32[] = {PPC::R3, PPC::R4, PPC::R5, PPC::R6,
PPC::R7, PPC::R8, PPC::R9, PPC::R10};
static const MCPhysReg GPR_64[] = {PPC::X3, PPC::X4, PPC::X5, PPC::X6,
PPC::X7, PPC::X8, PPC::X9, PPC::X10};
const unsigned NumGPArgRegs = array_lengthof(IsPPC64 ? GPR_64 : GPR_32);
// The fixed integer arguments of a variadic function are stored to the
// VarArgsFrameIndex on the stack so that they may be loaded by
// dereferencing the result of va_next.
for (unsigned GPRIndex =
(CCInfo.getNextStackOffset() - LinkageSize) / PtrByteSize;
GPRIndex < NumGPArgRegs; ++GPRIndex) {
const Register VReg =
IsPPC64 ? MF.addLiveIn(GPR_64[GPRIndex], &PPC::G8RCRegClass)
: MF.addLiveIn(GPR_32[GPRIndex], &PPC::GPRCRegClass);
SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
SDValue Store =
DAG.getStore(Val.getValue(1), dl, Val, FIN, MachinePointerInfo());
MemOps.push_back(Store);
// Increment the address for the next argument to store.
SDValue PtrOff = DAG.getConstant(PtrByteSize, dl, PtrVT);
FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
}
}
if (!MemOps.empty())
Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
return Chain;
}
SDValue PPCTargetLowering::LowerCall_AIX(
SDValue Chain, SDValue Callee, CallFlags CFlags,
const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals,
const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals,
const CallBase *CB) const {
// See PPCTargetLowering::LowerFormalArguments_AIX() for a description of the
// AIX ABI stack frame layout.
assert((CFlags.CallConv == CallingConv::C ||
CFlags.CallConv == CallingConv::Cold ||
CFlags.CallConv == CallingConv::Fast) &&
"Unexpected calling convention!");
if (CFlags.IsPatchPoint)
report_fatal_error("This call type is unimplemented on AIX.");
const PPCSubtarget& Subtarget =
static_cast<const PPCSubtarget&>(DAG.getSubtarget());
MachineFunction &MF = DAG.getMachineFunction();
SmallVector<CCValAssign, 16> ArgLocs;
AIXCCState CCInfo(CFlags.CallConv, CFlags.IsVarArg, MF, ArgLocs,
*DAG.getContext());
// Reserve space for the linkage save area (LSA) on the stack.
// In both PPC32 and PPC64 there are 6 reserved slots in the LSA:
// [SP][CR][LR][2 x reserved][TOC].
// The LSA is 24 bytes (6x4) in PPC32 and 48 bytes (6x8) in PPC64.
const unsigned LinkageSize = Subtarget.getFrameLowering()->getLinkageSize();
const bool IsPPC64 = Subtarget.isPPC64();
const EVT PtrVT = getPointerTy(DAG.getDataLayout());
const unsigned PtrByteSize = IsPPC64 ? 8 : 4;
CCInfo.AllocateStack(LinkageSize, Align(PtrByteSize));
CCInfo.AnalyzeCallOperands(Outs, CC_AIX);
// The prolog code of the callee may store up to 8 GPR argument registers to
// the stack, allowing va_start to index over them in memory if the callee
// is variadic.
// Because we cannot tell if this is needed on the caller side, we have to
// conservatively assume that it is needed. As such, make sure we have at
// least enough stack space for the caller to store the 8 GPRs.
const unsigned MinParameterSaveAreaSize = 8 * PtrByteSize;
const unsigned NumBytes = std::max(LinkageSize + MinParameterSaveAreaSize,
CCInfo.getNextStackOffset());
// Adjust the stack pointer for the new arguments...
// These operations are automatically eliminated by the prolog/epilog pass.
Chain = DAG.getCALLSEQ_START(Chain, NumBytes, 0, dl);
SDValue CallSeqStart = Chain;
SmallVector<std::pair<unsigned, SDValue>, 8> RegsToPass;
SmallVector<SDValue, 8> MemOpChains;
// Set up a copy of the stack pointer for loading and storing any
// arguments that may not fit in the registers available for argument
// passing.
const SDValue StackPtr = IsPPC64 ? DAG.getRegister(PPC::X1, MVT::i64)
: DAG.getRegister(PPC::R1, MVT::i32);
for (unsigned I = 0, E = ArgLocs.size(); I != E;) {
const unsigned ValNo = ArgLocs[I].getValNo();
SDValue Arg = OutVals[ValNo];
ISD::ArgFlagsTy Flags = Outs[ValNo].Flags;
if (Flags.isByVal()) {
const unsigned ByValSize = Flags.getByValSize();
// Nothing to do for zero-sized ByVals on the caller side.
if (!ByValSize) {
++I;
continue;
}
auto GetLoad = [&](EVT VT, unsigned LoadOffset) {
return DAG.getExtLoad(
ISD::ZEXTLOAD, dl, PtrVT, Chain,
(LoadOffset != 0)
? DAG.getObjectPtrOffset(dl, Arg, TypeSize::Fixed(LoadOffset))
: Arg,
MachinePointerInfo(), VT);
};
unsigned LoadOffset = 0;
// Initialize registers, which are fully occupied by the by-val argument.
while (LoadOffset + PtrByteSize <= ByValSize && ArgLocs[I].isRegLoc()) {
SDValue Load = GetLoad(PtrVT, LoadOffset);
MemOpChains.push_back(Load.getValue(1));
LoadOffset += PtrByteSize;
const CCValAssign &ByValVA = ArgLocs[I++];
assert(ByValVA.getValNo() == ValNo &&
"Unexpected location for pass-by-value argument.");
RegsToPass.push_back(std::make_pair(ByValVA.getLocReg(), Load));
}
if (LoadOffset == ByValSize)
continue;
// There must be one more loc to handle the remainder.
assert(ArgLocs[I].getValNo() == ValNo &&
"Expected additional location for by-value argument.");
if (ArgLocs[I].isMemLoc()) {
assert(LoadOffset < ByValSize && "Unexpected memloc for by-val arg.");
const CCValAssign &ByValVA = ArgLocs[I++];
ISD::ArgFlagsTy MemcpyFlags = Flags;
// Only memcpy the bytes that don't pass in register.
MemcpyFlags.setByValSize(ByValSize - LoadOffset);
Chain = CallSeqStart = createMemcpyOutsideCallSeq(
(LoadOffset != 0)
? DAG.getObjectPtrOffset(dl, Arg, TypeSize::Fixed(LoadOffset))
: Arg,
DAG.getObjectPtrOffset(dl, StackPtr,
TypeSize::Fixed(ByValVA.getLocMemOffset())),
CallSeqStart, MemcpyFlags, DAG, dl);
continue;
}
// Initialize the final register residue.
// Any residue that occupies the final by-val arg register must be
// left-justified on AIX. Loads must be a power-of-2 size and cannot be
// larger than the ByValSize. For example: a 7 byte by-val arg requires 4,
// 2 and 1 byte loads.
const unsigned ResidueBytes = ByValSize % PtrByteSize;
assert(ResidueBytes != 0 && LoadOffset + PtrByteSize > ByValSize &&
"Unexpected register residue for by-value argument.");
SDValue ResidueVal;
for (unsigned Bytes = 0; Bytes != ResidueBytes;) {
const unsigned N = PowerOf2Floor(ResidueBytes - Bytes);
const MVT VT =
N == 1 ? MVT::i8
: ((N == 2) ? MVT::i16 : (N == 4 ? MVT::i32 : MVT::i64));
SDValue Load = GetLoad(VT, LoadOffset);
MemOpChains.push_back(Load.getValue(1));
LoadOffset += N;
Bytes += N;
// By-val arguments are passed left-justfied in register.
// Every load here needs to be shifted, otherwise a full register load
// should have been used.
assert(PtrVT.getSimpleVT().getSizeInBits() > (Bytes * 8) &&
"Unexpected load emitted during handling of pass-by-value "
"argument.");
unsigned NumSHLBits = PtrVT.getSimpleVT().getSizeInBits() - (Bytes * 8);
EVT ShiftAmountTy =
getShiftAmountTy(Load->getValueType(0), DAG.getDataLayout());
SDValue SHLAmt = DAG.getConstant(NumSHLBits, dl, ShiftAmountTy);
SDValue ShiftedLoad =
DAG.getNode(ISD::SHL, dl, Load.getValueType(), Load, SHLAmt);
ResidueVal = ResidueVal ? DAG.getNode(ISD::OR, dl, PtrVT, ResidueVal,
ShiftedLoad)
: ShiftedLoad;
}
const CCValAssign &ByValVA = ArgLocs[I++];
RegsToPass.push_back(std::make_pair(ByValVA.getLocReg(), ResidueVal));
continue;
}
CCValAssign &VA = ArgLocs[I++];
const MVT LocVT = VA.getLocVT();
const MVT ValVT = VA.getValVT();
switch (VA.getLocInfo()) {
default:
report_fatal_error("Unexpected argument extension type.");
case CCValAssign::Full:
break;
case CCValAssign::ZExt:
Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
break;
case CCValAssign::SExt:
Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
break;
}
if (VA.isRegLoc() && !VA.needsCustom()) {
RegsToPass.push_back(std::make_pair(VA.getLocReg(), Arg));
continue;
}
// Vector arguments passed to VarArg functions need custom handling when
// they are passed (at least partially) in GPRs.
if (VA.isMemLoc() && VA.needsCustom() && ValVT.isVector()) {
assert(CFlags.IsVarArg && "Custom MemLocs only used for Vector args.");
// Store value to its stack slot.
SDValue PtrOff =
DAG.getConstant(VA.getLocMemOffset(), dl, StackPtr.getValueType());
PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr, PtrOff);
SDValue Store =
DAG.getStore(Chain, dl, Arg, PtrOff, MachinePointerInfo());
MemOpChains.push_back(Store);
const unsigned OriginalValNo = VA.getValNo();
// Then load the GPRs from the stack
unsigned LoadOffset = 0;
auto HandleCustomVecRegLoc = [&]() {
assert(I != E && "Unexpected end of CCvalAssigns.");
assert(ArgLocs[I].isRegLoc() && ArgLocs[I].needsCustom() &&
"Expected custom RegLoc.");
CCValAssign RegVA = ArgLocs[I++];
assert(RegVA.getValNo() == OriginalValNo &&
"Custom MemLoc ValNo and custom RegLoc ValNo must match.");
SDValue Add = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff,
DAG.getConstant(LoadOffset, dl, PtrVT));
SDValue Load = DAG.getLoad(PtrVT, dl, Store, Add, MachinePointerInfo());
MemOpChains.push_back(Load.getValue(1));
RegsToPass.push_back(std::make_pair(RegVA.getLocReg(), Load));
LoadOffset += PtrByteSize;
};
// In 64-bit there will be exactly 2 custom RegLocs that follow, and in
// in 32-bit there will be 2 custom RegLocs if we are passing in R9 and
// R10.
HandleCustomVecRegLoc();
HandleCustomVecRegLoc();
if (I != E && ArgLocs[I].isRegLoc() && ArgLocs[I].needsCustom() &&
ArgLocs[I].getValNo() == OriginalValNo) {
assert(!IsPPC64 &&
"Only 2 custom RegLocs expected for 64-bit codegen.");
HandleCustomVecRegLoc();
HandleCustomVecRegLoc();
}
continue;
}
if (VA.isMemLoc()) {
SDValue PtrOff =
DAG.getConstant(VA.getLocMemOffset(), dl, StackPtr.getValueType());
PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr, PtrOff);
MemOpChains.push_back(
DAG.getStore(Chain, dl, Arg, PtrOff, MachinePointerInfo()));
continue;
}
if (!ValVT.isFloatingPoint())
report_fatal_error(
"Unexpected register handling for calling convention.");
// Custom handling is used for GPR initializations for vararg float
// arguments.
assert(VA.isRegLoc() && VA.needsCustom() && CFlags.IsVarArg &&
LocVT.isInteger() &&
"Custom register handling only expected for VarArg.");
SDValue ArgAsInt =
DAG.getBitcast(MVT::getIntegerVT(ValVT.getSizeInBits()), Arg);
if (Arg.getValueType().getStoreSize() == LocVT.getStoreSize())
// f32 in 32-bit GPR
// f64 in 64-bit GPR
RegsToPass.push_back(std::make_pair(VA.getLocReg(), ArgAsInt));
else if (Arg.getValueType().getFixedSizeInBits() <
LocVT.getFixedSizeInBits())
// f32 in 64-bit GPR.
RegsToPass.push_back(std::make_pair(
VA.getLocReg(), DAG.getZExtOrTrunc(ArgAsInt, dl, LocVT)));
else {
// f64 in two 32-bit GPRs
// The 2 GPRs are marked custom and expected to be adjacent in ArgLocs.
assert(Arg.getValueType() == MVT::f64 && CFlags.IsVarArg && !IsPPC64 &&
"Unexpected custom register for argument!");
CCValAssign &GPR1 = VA;
SDValue MSWAsI64 = DAG.getNode(ISD::SRL, dl, MVT::i64, ArgAsInt,
DAG.getConstant(32, dl, MVT::i8));
RegsToPass.push_back(std::make_pair(
GPR1.getLocReg(), DAG.getZExtOrTrunc(MSWAsI64, dl, MVT::i32)));
if (I != E) {
// If only 1 GPR was available, there will only be one custom GPR and
// the argument will also pass in memory.
CCValAssign &PeekArg = ArgLocs[I];
if (PeekArg.isRegLoc() && PeekArg.getValNo() == PeekArg.getValNo()) {
assert(PeekArg.needsCustom() && "A second custom GPR is expected.");
CCValAssign &GPR2 = ArgLocs[I++];
RegsToPass.push_back(std::make_pair(
GPR2.getLocReg(), DAG.getZExtOrTrunc(ArgAsInt, dl, MVT::i32)));
}
}
}
}
if (!MemOpChains.empty())
Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
// For indirect calls, we need to save the TOC base to the stack for
// restoration after the call.
if (CFlags.IsIndirect) {
assert(!CFlags.IsTailCall && "Indirect tail-calls not supported.");
const MCRegister TOCBaseReg = Subtarget.getTOCPointerRegister();
const MCRegister StackPtrReg = Subtarget.getStackPointerRegister();
const MVT PtrVT = Subtarget.isPPC64() ? MVT::i64 : MVT::i32;
const unsigned TOCSaveOffset =
Subtarget.getFrameLowering()->getTOCSaveOffset();
setUsesTOCBasePtr(DAG);
SDValue Val = DAG.getCopyFromReg(Chain, dl, TOCBaseReg, PtrVT);
SDValue PtrOff = DAG.getIntPtrConstant(TOCSaveOffset, dl);
SDValue StackPtr = DAG.getRegister(StackPtrReg, PtrVT);
SDValue AddPtr = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr, PtrOff);
Chain = DAG.getStore(
Val.getValue(1), dl, Val, AddPtr,
MachinePointerInfo::getStack(DAG.getMachineFunction(), TOCSaveOffset));
}
// Build a sequence of copy-to-reg nodes chained together with token chain
// and flag operands which copy the outgoing args into the appropriate regs.
SDValue InFlag;
for (auto Reg : RegsToPass) {
Chain = DAG.getCopyToReg(Chain, dl, Reg.first, Reg.second, InFlag);
InFlag = Chain.getValue(1);
}
const int SPDiff = 0;
return FinishCall(CFlags, dl, DAG, RegsToPass, InFlag, Chain, CallSeqStart,
Callee, SPDiff, NumBytes, Ins, InVals, CB);
}
bool
PPCTargetLowering::CanLowerReturn(CallingConv::ID CallConv,
MachineFunction &MF, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs,
LLVMContext &Context) const {
SmallVector<CCValAssign, 16> RVLocs;
CCState CCInfo(CallConv, isVarArg, MF, RVLocs, Context);
return CCInfo.CheckReturn(
Outs, (Subtarget.isSVR4ABI() && CallConv == CallingConv::Cold)
? RetCC_PPC_Cold
: RetCC_PPC);
}
SDValue
PPCTargetLowering::LowerReturn(SDValue Chain, CallingConv::ID CallConv,
bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals,
const SDLoc &dl, SelectionDAG &DAG) const {
SmallVector<CCValAssign, 16> RVLocs;
CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(), RVLocs,
*DAG.getContext());
CCInfo.AnalyzeReturn(Outs,
(Subtarget.isSVR4ABI() && CallConv == CallingConv::Cold)
? RetCC_PPC_Cold
: RetCC_PPC);
SDValue Flag;
SmallVector<SDValue, 4> RetOps(1, Chain);
// Copy the result values into the output registers.
for (unsigned i = 0, RealResIdx = 0; i != RVLocs.size(); ++i, ++RealResIdx) {
CCValAssign &VA = RVLocs[i];
assert(VA.isRegLoc() && "Can only return in registers!");
SDValue Arg = OutVals[RealResIdx];
switch (VA.getLocInfo()) {
default: llvm_unreachable("Unknown loc info!");
case CCValAssign::Full: break;
case CCValAssign::AExt:
Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
break;
case CCValAssign::ZExt:
Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
break;
case CCValAssign::SExt:
Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
break;
}
if (Subtarget.hasSPE() && VA.getLocVT() == MVT::f64) {
bool isLittleEndian = Subtarget.isLittleEndian();
// Legalize ret f64 -> ret 2 x i32.
SDValue SVal =
DAG.getNode(PPCISD::EXTRACT_SPE, dl, MVT::i32, Arg,
DAG.getIntPtrConstant(isLittleEndian ? 0 : 1, dl));
Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), SVal, Flag);
RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
SVal = DAG.getNode(PPCISD::EXTRACT_SPE, dl, MVT::i32, Arg,
DAG.getIntPtrConstant(isLittleEndian ? 1 : 0, dl));
Flag = Chain.getValue(1);
VA = RVLocs[++i]; // skip ahead to next loc
Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), SVal, Flag);
} else
Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), Arg, Flag);
Flag = Chain.getValue(1);
RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
}
RetOps[0] = Chain; // Update chain.
// Add the flag if we have it.
if (Flag.getNode())
RetOps.push_back(Flag);
return DAG.getNode(PPCISD::RET_FLAG, dl, MVT::Other, RetOps);
}
SDValue
PPCTargetLowering::LowerGET_DYNAMIC_AREA_OFFSET(SDValue Op,
SelectionDAG &DAG) const {
SDLoc dl(Op);
// Get the correct type for integers.
EVT IntVT = Op.getValueType();
// Get the inputs.
SDValue Chain = Op.getOperand(0);
SDValue FPSIdx = getFramePointerFrameIndex(DAG);
// Build a DYNAREAOFFSET node.
SDValue Ops[2] = {Chain, FPSIdx};
SDVTList VTs = DAG.getVTList(IntVT);
return DAG.getNode(PPCISD::DYNAREAOFFSET, dl, VTs, Ops);
}
SDValue PPCTargetLowering::LowerSTACKRESTORE(SDValue Op,
SelectionDAG &DAG) const {
// When we pop the dynamic allocation we need to restore the SP link.
SDLoc dl(Op);
// Get the correct type for pointers.
EVT PtrVT = getPointerTy(DAG.getDataLayout());
// Construct the stack pointer operand.
bool isPPC64 = Subtarget.isPPC64();
unsigned SP = isPPC64 ? PPC::X1 : PPC::R1;
SDValue StackPtr = DAG.getRegister(SP, PtrVT);
// Get the operands for the STACKRESTORE.
SDValue Chain = Op.getOperand(0);
SDValue SaveSP = Op.getOperand(1);
// Load the old link SP.
SDValue LoadLinkSP =
DAG.getLoad(PtrVT, dl, Chain, StackPtr, MachinePointerInfo());
// Restore the stack pointer.
Chain = DAG.getCopyToReg(LoadLinkSP.getValue(1), dl, SP, SaveSP);
// Store the old link SP.
return DAG.getStore(Chain, dl, LoadLinkSP, StackPtr, MachinePointerInfo());
}
SDValue PPCTargetLowering::getReturnAddrFrameIndex(SelectionDAG &DAG) const {
MachineFunction &MF = DAG.getMachineFunction();
bool isPPC64 = Subtarget.isPPC64();
EVT PtrVT = getPointerTy(MF.getDataLayout());
// Get current frame pointer save index. The users of this index will be
// primarily DYNALLOC instructions.
PPCFunctionInfo *FI = MF.getInfo<PPCFunctionInfo>();
int RASI = FI->getReturnAddrSaveIndex();
// If the frame pointer save index hasn't been defined yet.
if (!RASI) {
// Find out what the fix offset of the frame pointer save area.
int LROffset = Subtarget.getFrameLowering()->getReturnSaveOffset();
// Allocate the frame index for frame pointer save area.
RASI = MF.getFrameInfo().CreateFixedObject(isPPC64? 8 : 4, LROffset, false);
// Save the result.
FI->setReturnAddrSaveIndex(RASI);
}
return DAG.getFrameIndex(RASI, PtrVT);
}
SDValue
PPCTargetLowering::getFramePointerFrameIndex(SelectionDAG & DAG) const {
MachineFunction &MF = DAG.getMachineFunction();
bool isPPC64 = Subtarget.isPPC64();
EVT PtrVT = getPointerTy(MF.getDataLayout());
// Get current frame pointer save index. The users of this index will be
// primarily DYNALLOC instructions.
PPCFunctionInfo *FI = MF.getInfo<PPCFunctionInfo>();
int FPSI = FI->getFramePointerSaveIndex();
// If the frame pointer save index hasn't been defined yet.
if (!FPSI) {
// Find out what the fix offset of the frame pointer save area.
int FPOffset = Subtarget.getFrameLowering()->getFramePointerSaveOffset();
// Allocate the frame index for frame pointer save area.
FPSI = MF.getFrameInfo().CreateFixedObject(isPPC64? 8 : 4, FPOffset, true);
// Save the result.
FI->setFramePointerSaveIndex(FPSI);
}
return DAG.getFrameIndex(FPSI, PtrVT);
}
SDValue PPCTargetLowering::LowerDYNAMIC_STACKALLOC(SDValue Op,
SelectionDAG &DAG) const {
MachineFunction &MF = DAG.getMachineFunction();
// Get the inputs.
SDValue Chain = Op.getOperand(0);
SDValue Size = Op.getOperand(1);
SDLoc dl(Op);
// Get the correct type for pointers.
EVT PtrVT = getPointerTy(DAG.getDataLayout());
// Negate the size.
SDValue NegSize = DAG.getNode(ISD::SUB, dl, PtrVT,
DAG.getConstant(0, dl, PtrVT), Size);
// Construct a node for the frame pointer save index.
SDValue FPSIdx = getFramePointerFrameIndex(DAG);
SDValue Ops[3] = { Chain, NegSize, FPSIdx };
SDVTList VTs = DAG.getVTList(PtrVT, MVT::Other);
if (hasInlineStackProbe(MF))
return DAG.getNode(PPCISD::PROBED_ALLOCA, dl, VTs, Ops);
return DAG.getNode(PPCISD::DYNALLOC, dl, VTs, Ops);
}
SDValue PPCTargetLowering::LowerEH_DWARF_CFA(SDValue Op,
SelectionDAG &DAG) const {
MachineFunction &MF = DAG.getMachineFunction();
bool isPPC64 = Subtarget.isPPC64();
EVT PtrVT = getPointerTy(DAG.getDataLayout());
int FI = MF.getFrameInfo().CreateFixedObject(isPPC64 ? 8 : 4, 0, false);
return DAG.getFrameIndex(FI, PtrVT);
}
SDValue PPCTargetLowering::lowerEH_SJLJ_SETJMP(SDValue Op,
SelectionDAG &DAG) const {
SDLoc DL(Op);
return DAG.getNode(PPCISD::EH_SJLJ_SETJMP, DL,
DAG.getVTList(MVT::i32, MVT::Other),
Op.getOperand(0), Op.getOperand(1));
}
SDValue PPCTargetLowering::lowerEH_SJLJ_LONGJMP(SDValue Op,
SelectionDAG &DAG) const {
SDLoc DL(Op);
return DAG.getNode(PPCISD::EH_SJLJ_LONGJMP, DL, MVT::Other,
Op.getOperand(0), Op.getOperand(1));
}
SDValue PPCTargetLowering::LowerLOAD(SDValue Op, SelectionDAG &DAG) const {
if (Op.getValueType().isVector())
return LowerVectorLoad(Op, DAG);
assert(Op.getValueType() == MVT::i1 &&
"Custom lowering only for i1 loads");
// First, load 8 bits into 32 bits, then truncate to 1 bit.
SDLoc dl(Op);
LoadSDNode *LD = cast<LoadSDNode>(Op);
SDValue Chain = LD->getChain();
SDValue BasePtr = LD->getBasePtr();
MachineMemOperand *MMO = LD->getMemOperand();
SDValue NewLD =
DAG.getExtLoad(ISD::EXTLOAD, dl, getPointerTy(DAG.getDataLayout()), Chain,
BasePtr, MVT::i8, MMO);
SDValue Result = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, NewLD);
SDValue Ops[] = { Result, SDValue(NewLD.getNode(), 1) };
return DAG.getMergeValues(Ops, dl);
}
SDValue PPCTargetLowering::LowerSTORE(SDValue Op, SelectionDAG &DAG) const {
if (Op.getOperand(1).getValueType().isVector())
return LowerVectorStore(Op, DAG);
assert(Op.getOperand(1).getValueType() == MVT::i1 &&
"Custom lowering only for i1 stores");
// First, zero extend to 32 bits, then use a truncating store to 8 bits.
SDLoc dl(Op);
StoreSDNode *ST = cast<StoreSDNode>(Op);
SDValue Chain = ST->getChain();
SDValue BasePtr = ST->getBasePtr();
SDValue Value = ST->getValue();
MachineMemOperand *MMO = ST->getMemOperand();
Value = DAG.getNode(ISD::ZERO_EXTEND, dl, getPointerTy(DAG.getDataLayout()),
Value);
return DAG.getTruncStore(Chain, dl, Value, BasePtr, MVT::i8, MMO);
}
// FIXME: Remove this once the ANDI glue bug is fixed:
SDValue PPCTargetLowering::LowerTRUNCATE(SDValue Op, SelectionDAG &DAG) const {
assert(Op.getValueType() == MVT::i1 &&
"Custom lowering only for i1 results");
SDLoc DL(Op);
return DAG.getNode(PPCISD::ANDI_rec_1_GT_BIT, DL, MVT::i1, Op.getOperand(0));
}
SDValue PPCTargetLowering::LowerTRUNCATEVector(SDValue Op,
SelectionDAG &DAG) const {
// Implements a vector truncate that fits in a vector register as a shuffle.
// We want to legalize vector truncates down to where the source fits in
// a vector register (and target is therefore smaller than vector register
// size). At that point legalization will try to custom lower the sub-legal
// result and get here - where we can contain the truncate as a single target
// operation.
// For example a trunc <2 x i16> to <2 x i8> could be visualized as follows:
// <MSB1|LSB1, MSB2|LSB2> to <LSB1, LSB2>
//
// We will implement it for big-endian ordering as this (where x denotes
// undefined):
// < MSB1|LSB1, MSB2|LSB2, uu, uu, uu, uu, uu, uu> to
// < LSB1, LSB2, u, u, u, u, u, u, u, u, u, u, u, u, u, u>
//
// The same operation in little-endian ordering will be:
// <uu, uu, uu, uu, uu, uu, LSB2|MSB2, LSB1|MSB1> to
// <u, u, u, u, u, u, u, u, u, u, u, u, u, u, LSB2, LSB1>
EVT TrgVT = Op.getValueType();
assert(TrgVT.isVector() && "Vector type expected.");
unsigned TrgNumElts = TrgVT.getVectorNumElements();
EVT EltVT = TrgVT.getVectorElementType();
if (!isOperationCustom(Op.getOpcode(), TrgVT) ||
TrgVT.getSizeInBits() > 128 || !isPowerOf2_32(TrgNumElts) ||
!isPowerOf2_32(EltVT.getSizeInBits()))
return SDValue();
SDValue N1 = Op.getOperand(0);
EVT SrcVT = N1.getValueType();
unsigned SrcSize = SrcVT.getSizeInBits();
if (SrcSize > 256 ||
!isPowerOf2_32(SrcVT.getVectorNumElements()) ||
!isPowerOf2_32(SrcVT.getVectorElementType().getSizeInBits()))
return SDValue();
if (SrcSize == 256 && SrcVT.getVectorNumElements() < 2)
return SDValue();
unsigned WideNumElts = 128 / EltVT.getSizeInBits();
EVT WideVT = EVT::getVectorVT(*DAG.getContext(), EltVT, WideNumElts);
SDLoc DL(Op);
SDValue Op1, Op2;
if (SrcSize == 256) {
EVT VecIdxTy = getVectorIdxTy(DAG.getDataLayout());
EVT SplitVT =
N1.getValueType().getHalfNumVectorElementsVT(*DAG.getContext());
unsigned SplitNumElts = SplitVT.getVectorNumElements();
Op1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SplitVT, N1,
DAG.getConstant(0, DL, VecIdxTy));
Op2 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SplitVT, N1,
DAG.getConstant(SplitNumElts, DL, VecIdxTy));
}
else {
Op1 = SrcSize == 128 ? N1 : widenVec(DAG, N1, DL);
Op2 = DAG.getUNDEF(WideVT);
}
// First list the elements we want to keep.
unsigned SizeMult = SrcSize / TrgVT.getSizeInBits();
SmallVector<int, 16> ShuffV;
if (Subtarget.isLittleEndian())
for (unsigned i = 0; i < TrgNumElts; ++i)
ShuffV.push_back(i * SizeMult);
else
for (unsigned i = 1; i <= TrgNumElts; ++i)
ShuffV.push_back(i * SizeMult - 1);
// Populate the remaining elements with undefs.
for (unsigned i = TrgNumElts; i < WideNumElts; ++i)
// ShuffV.push_back(i + WideNumElts);
ShuffV.push_back(WideNumElts + 1);
Op1 = DAG.getNode(ISD::BITCAST, DL, WideVT, Op1);
Op2 = DAG.getNode(ISD::BITCAST, DL, WideVT, Op2);
return DAG.getVectorShuffle(WideVT, DL, Op1, Op2, ShuffV);
}
/// LowerSELECT_CC - Lower floating point select_cc's into fsel instruction when
/// possible.
SDValue PPCTargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const {
ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get();
EVT ResVT = Op.getValueType();
EVT CmpVT = Op.getOperand(0).getValueType();
SDValue LHS = Op.getOperand(0), RHS = Op.getOperand(1);
SDValue TV = Op.getOperand(2), FV = Op.getOperand(3);
SDLoc dl(Op);
// Without power9-vector, we don't have native instruction for f128 comparison.
// Following transformation to libcall is needed for setcc:
// select_cc lhs, rhs, tv, fv, cc -> select_cc (setcc cc, x, y), 0, tv, fv, NE
if (!Subtarget.hasP9Vector() && CmpVT == MVT::f128) {
SDValue Z = DAG.getSetCC(
dl, getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), CmpVT),
LHS, RHS, CC);
SDValue Zero = DAG.getConstant(0, dl, Z.getValueType());
return DAG.getSelectCC(dl, Z, Zero, TV, FV, ISD::SETNE);
}
// Not FP, or using SPE? Not a fsel.
if (!CmpVT.isFloatingPoint() || !TV.getValueType().isFloatingPoint() ||
Subtarget.hasSPE())
return Op;
SDNodeFlags Flags = Op.getNode()->getFlags();
// We have xsmaxcdp/xsmincdp which are OK to emit even in the
// presence of infinities.
if (Subtarget.hasP9Vector() && LHS == TV && RHS == FV) {
switch (CC) {
default:
break;
case ISD::SETOGT:
case ISD::SETGT:
return DAG.getNode(PPCISD::XSMAXCDP, dl, Op.getValueType(), LHS, RHS);
case ISD::SETOLT:
case ISD::SETLT:
return DAG.getNode(PPCISD::XSMINCDP, dl, Op.getValueType(), LHS, RHS);
}
}
// We might be able to do better than this under some circumstances, but in
// general, fsel-based lowering of select is a finite-math-only optimization.
// For more information, see section F.3 of the 2.06 ISA specification.
// With ISA 3.0
if ((!DAG.getTarget().Options.NoInfsFPMath && !Flags.hasNoInfs()) ||
(!DAG.getTarget().Options.NoNaNsFPMath && !Flags.hasNoNaNs()))
return Op;
// If the RHS of the comparison is a 0.0, we don't need to do the
// subtraction at all.
SDValue Sel1;
if (isFloatingPointZero(RHS))
switch (CC) {
default: break; // SETUO etc aren't handled by fsel.
case ISD::SETNE:
std::swap(TV, FV);
LLVM_FALLTHROUGH;
case ISD::SETEQ:
if (LHS.getValueType() == MVT::f32) // Comparison is always 64-bits
LHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, LHS);
Sel1 = DAG.getNode(PPCISD::FSEL, dl, ResVT, LHS, TV, FV);
if (Sel1.getValueType() == MVT::f32) // Comparison is always 64-bits
Sel1 = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Sel1);
return DAG.getNode(PPCISD::FSEL, dl, ResVT,
DAG.getNode(ISD::FNEG, dl, MVT::f64, LHS), Sel1, FV);
case ISD::SETULT:
case ISD::SETLT:
std::swap(TV, FV); // fsel is natively setge, swap operands for setlt
LLVM_FALLTHROUGH;
case ISD::SETOGE:
case ISD::SETGE:
if (LHS.getValueType() == MVT::f32) // Comparison is always 64-bits
LHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, LHS);
return DAG.getNode(PPCISD::FSEL, dl, ResVT, LHS, TV, FV);
case ISD::SETUGT:
case ISD::SETGT:
std::swap(TV, FV); // fsel is natively setge, swap operands for setlt
LLVM_FALLTHROUGH;
case ISD::SETOLE:
case ISD::SETLE:
if (LHS.getValueType() == MVT::f32) // Comparison is always 64-bits
LHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, LHS);
return DAG.getNode(PPCISD::FSEL, dl, ResVT,
DAG.getNode(ISD::FNEG, dl, MVT::f64, LHS), TV, FV);
}
SDValue Cmp;
switch (CC) {
default: break; // SETUO etc aren't handled by fsel.
case ISD::SETNE:
std::swap(TV, FV);
LLVM_FALLTHROUGH;
case ISD::SETEQ:
Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, LHS, RHS, Flags);
if (Cmp.getValueType() == MVT::f32) // Comparison is always 64-bits
Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
Sel1 = DAG.getNode(PPCISD::FSEL, dl, ResVT, Cmp, TV, FV);
if (Sel1.getValueType() == MVT::f32) // Comparison is always 64-bits
Sel1 = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Sel1);
return DAG.getNode(PPCISD::FSEL, dl, ResVT,
DAG.getNode(ISD::FNEG, dl, MVT::f64, Cmp), Sel1, FV);
case ISD::SETULT:
case ISD::SETLT:
Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, LHS, RHS, Flags);
if (Cmp.getValueType() == MVT::f32) // Comparison is always 64-bits
Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
return DAG.getNode(PPCISD::FSEL, dl, ResVT, Cmp, FV, TV);
case ISD::SETOGE:
case ISD::SETGE:
Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, LHS, RHS, Flags);
if (Cmp.getValueType() == MVT::f32) // Comparison is always 64-bits
Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
return DAG.getNode(PPCISD::FSEL, dl, ResVT, Cmp, TV, FV);
case ISD::SETUGT:
case ISD::SETGT:
Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, RHS, LHS, Flags);
if (Cmp.getValueType() == MVT::f32) // Comparison is always 64-bits
Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
return DAG.getNode(PPCISD::FSEL, dl, ResVT, Cmp, FV, TV);
case ISD::SETOLE:
case ISD::SETLE:
Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, RHS, LHS, Flags);
if (Cmp.getValueType() == MVT::f32) // Comparison is always 64-bits
Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
return DAG.getNode(PPCISD::FSEL, dl, ResVT, Cmp, TV, FV);
}
return Op;
}
static unsigned getPPCStrictOpcode(unsigned Opc) {
switch (Opc) {
default:
llvm_unreachable("No strict version of this opcode!");
case PPCISD::FCTIDZ:
return PPCISD::STRICT_FCTIDZ;
case PPCISD::FCTIWZ:
return PPCISD::STRICT_FCTIWZ;
case PPCISD::FCTIDUZ:
return PPCISD::STRICT_FCTIDUZ;
case PPCISD::FCTIWUZ:
return PPCISD::STRICT_FCTIWUZ;
case PPCISD::FCFID:
return PPCISD::STRICT_FCFID;
case PPCISD::FCFIDU:
return PPCISD::STRICT_FCFIDU;
case PPCISD::FCFIDS:
return PPCISD::STRICT_FCFIDS;
case PPCISD::FCFIDUS:
return PPCISD::STRICT_FCFIDUS;
}
}
static SDValue convertFPToInt(SDValue Op, SelectionDAG &DAG,
const PPCSubtarget &Subtarget) {
SDLoc dl(Op);
bool IsStrict = Op->isStrictFPOpcode();
bool IsSigned = Op.getOpcode() == ISD::FP_TO_SINT ||
Op.getOpcode() == ISD::STRICT_FP_TO_SINT;
// TODO: Any other flags to propagate?
SDNodeFlags Flags;
Flags.setNoFPExcept(Op->getFlags().hasNoFPExcept());
// For strict nodes, source is the second operand.
SDValue Src = Op.getOperand(IsStrict ? 1 : 0);
SDValue Chain = IsStrict ? Op.getOperand(0) : SDValue();
assert(Src.getValueType().isFloatingPoint());
if (Src.getValueType() == MVT::f32) {
if (IsStrict) {
Src =
DAG.getNode(ISD::STRICT_FP_EXTEND, dl,
DAG.getVTList(MVT::f64, MVT::Other), {Chain, Src}, Flags);
Chain = Src.getValue(1);
} else
Src = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Src);
}
SDValue Conv;
unsigned Opc = ISD::DELETED_NODE;
switch (Op.getSimpleValueType().SimpleTy) {
default: llvm_unreachable("Unhandled FP_TO_INT type in custom expander!");
case MVT::i32:
Opc = IsSigned ? PPCISD::FCTIWZ
: (Subtarget.hasFPCVT() ? PPCISD::FCTIWUZ : PPCISD::FCTIDZ);
break;
case MVT::i64:
assert((IsSigned || Subtarget.hasFPCVT()) &&
"i64 FP_TO_UINT is supported only with FPCVT");
Opc = IsSigned ? PPCISD::FCTIDZ : PPCISD::FCTIDUZ;
}
if (IsStrict) {
Opc = getPPCStrictOpcode(Opc);
Conv = DAG.getNode(Opc, dl, DAG.getVTList(MVT::f64, MVT::Other),
{Chain, Src}, Flags);
} else {
Conv = DAG.getNode(Opc, dl, MVT::f64, Src);
}
return Conv;
}
void PPCTargetLowering::LowerFP_TO_INTForReuse(SDValue Op, ReuseLoadInfo &RLI,
SelectionDAG &DAG,
const SDLoc &dl) const {
SDValue Tmp = convertFPToInt(Op, DAG, Subtarget);
bool IsSigned = Op.getOpcode() == ISD::FP_TO_SINT ||
Op.getOpcode() == ISD::STRICT_FP_TO_SINT;
bool IsStrict = Op->isStrictFPOpcode();
// Convert the FP value to an int value through memory.
bool i32Stack = Op.getValueType() == MVT::i32 && Subtarget.hasSTFIWX() &&
(IsSigned || Subtarget.hasFPCVT());
SDValue FIPtr = DAG.CreateStackTemporary(i32Stack ? MVT::i32 : MVT::f64);
int FI = cast<FrameIndexSDNode>(FIPtr)->getIndex();
MachinePointerInfo MPI =
MachinePointerInfo::getFixedStack(DAG.getMachineFunction(), FI);
// Emit a store to the stack slot.
SDValue Chain = IsStrict ? Tmp.getValue(1) : DAG.getEntryNode();
Align Alignment(DAG.getEVTAlign(Tmp.getValueType()));
if (i32Stack) {
MachineFunction &MF = DAG.getMachineFunction();
Alignment = Align(4);
MachineMemOperand *MMO =
MF.getMachineMemOperand(MPI, MachineMemOperand::MOStore, 4, Alignment);
SDValue Ops[] = { Chain, Tmp, FIPtr };
Chain = DAG.getMemIntrinsicNode(PPCISD::STFIWX, dl,
DAG.getVTList(MVT::Other), Ops, MVT::i32, MMO);
} else
Chain = DAG.getStore(Chain, dl, Tmp, FIPtr, MPI, Alignment);
// Result is a load from the stack slot. If loading 4 bytes, make sure to
// add in a bias on big endian.
if (Op.getValueType() == MVT::i32 && !i32Stack) {
FIPtr = DAG.getNode(ISD::ADD, dl, FIPtr.getValueType(), FIPtr,
DAG.getConstant(4, dl, FIPtr.getValueType()));
MPI = MPI.getWithOffset(Subtarget.isLittleEndian() ? 0 : 4);
}
RLI.Chain = Chain;
RLI.Ptr = FIPtr;
RLI.MPI = MPI;
RLI.Alignment = Alignment;
}
/// Custom lowers floating point to integer conversions to use
/// the direct move instructions available in ISA 2.07 to avoid the
/// need for load/store combinations.
SDValue PPCTargetLowering::LowerFP_TO_INTDirectMove(SDValue Op,
SelectionDAG &DAG,
const SDLoc &dl) const {
SDValue Conv = convertFPToInt(Op, DAG, Subtarget);
SDValue Mov = DAG.getNode(PPCISD::MFVSR, dl, Op.getValueType(), Conv);
if (Op->isStrictFPOpcode())
return DAG.getMergeValues({Mov, Conv.getValue(1)}, dl);
else
return Mov;
}
SDValue PPCTargetLowering::LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG,
const SDLoc &dl) const {
bool IsStrict = Op->isStrictFPOpcode();
bool IsSigned = Op.getOpcode() == ISD::FP_TO_SINT ||
Op.getOpcode() == ISD::STRICT_FP_TO_SINT;
SDValue Src = Op.getOperand(IsStrict ? 1 : 0);
EVT SrcVT = Src.getValueType();
EVT DstVT = Op.getValueType();
// FP to INT conversions are legal for f128.
if (SrcVT == MVT::f128)
return Subtarget.hasP9Vector() ? Op : SDValue();
// Expand ppcf128 to i32 by hand for the benefit of llvm-gcc bootstrap on
// PPC (the libcall is not available).
if (SrcVT == MVT::ppcf128) {
if (DstVT == MVT::i32) {
// TODO: Conservatively pass only nofpexcept flag here. Need to check and
// set other fast-math flags to FP operations in both strict and
// non-strict cases. (FP_TO_SINT, FSUB)
SDNodeFlags Flags;
Flags.setNoFPExcept(Op->getFlags().hasNoFPExcept());
if (IsSigned) {
SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::f64, Src,
DAG.getIntPtrConstant(0, dl));
SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::f64, Src,
DAG.getIntPtrConstant(1, dl));
// Add the two halves of the long double in round-to-zero mode, and use
// a smaller FP_TO_SINT.
if (IsStrict) {
SDValue Res = DAG.getNode(PPCISD::STRICT_FADDRTZ, dl,
DAG.getVTList(MVT::f64, MVT::Other),
{Op.getOperand(0), Lo, Hi}, Flags);
return DAG.getNode(ISD::STRICT_FP_TO_SINT, dl,
DAG.getVTList(MVT::i32, MVT::Other),
{Res.getValue(1), Res}, Flags);
} else {
SDValue Res = DAG.getNode(PPCISD::FADDRTZ, dl, MVT::f64, Lo, Hi);
return DAG.getNode(ISD::FP_TO_SINT, dl, MVT::i32, Res);
}
} else {
const uint64_t TwoE31[] = {0x41e0000000000000LL, 0};
APFloat APF = APFloat(APFloat::PPCDoubleDouble(), APInt(128, TwoE31));
SDValue Cst = DAG.getConstantFP(APF, dl, SrcVT);
SDValue SignMask = DAG.getConstant(0x80000000, dl, DstVT);
if (IsStrict) {
// Sel = Src < 0x80000000
// FltOfs = select Sel, 0.0, 0x80000000
// IntOfs = select Sel, 0, 0x80000000
// Result = fp_to_sint(Src - FltOfs) ^ IntOfs
SDValue Chain = Op.getOperand(0);
EVT SetCCVT =
getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), SrcVT);
EVT DstSetCCVT =
getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), DstVT);
SDValue Sel = DAG.getSetCC(dl, SetCCVT, Src, Cst, ISD::SETLT,
Chain, true);
Chain = Sel.getValue(1);
SDValue FltOfs = DAG.getSelect(
dl, SrcVT, Sel, DAG.getConstantFP(0.0, dl, SrcVT), Cst);
Sel = DAG.getBoolExtOrTrunc(Sel, dl, DstSetCCVT, DstVT);
SDValue Val = DAG.getNode(ISD::STRICT_FSUB, dl,
DAG.getVTList(SrcVT, MVT::Other),
{Chain, Src, FltOfs}, Flags);
Chain = Val.getValue(1);
SDValue SInt = DAG.getNode(ISD::STRICT_FP_TO_SINT, dl,
DAG.getVTList(DstVT, MVT::Other),
{Chain, Val}, Flags);
Chain = SInt.getValue(1);
SDValue IntOfs = DAG.getSelect(
dl, DstVT, Sel, DAG.getConstant(0, dl, DstVT), SignMask);
SDValue Result = DAG.getNode(ISD::XOR, dl, DstVT, SInt, IntOfs);
return DAG.getMergeValues({Result, Chain}, dl);
} else {
// X>=2^31 ? (int)(X-2^31)+0x80000000 : (int)X
// FIXME: generated code sucks.
SDValue True = DAG.getNode(ISD::FSUB, dl, MVT::ppcf128, Src, Cst);
True = DAG.getNode(ISD::FP_TO_SINT, dl, MVT::i32, True);
True = DAG.getNode(ISD::ADD, dl, MVT::i32, True, SignMask);
SDValue False = DAG.getNode(ISD::FP_TO_SINT, dl, MVT::i32, Src);
return DAG.getSelectCC(dl, Src, Cst, True, False, ISD::SETGE);
}
}
}
return SDValue();
}
if (Subtarget.hasDirectMove() && Subtarget.isPPC64())
return LowerFP_TO_INTDirectMove(Op, DAG, dl);
ReuseLoadInfo RLI;
LowerFP_TO_INTForReuse(Op, RLI, DAG, dl);
return DAG.getLoad(Op.getValueType(), dl, RLI.Chain, RLI.Ptr, RLI.MPI,
RLI.Alignment, RLI.MMOFlags(), RLI.AAInfo, RLI.Ranges);
}
// We're trying to insert a regular store, S, and then a load, L. If the
// incoming value, O, is a load, we might just be able to have our load use the
// address used by O. However, we don't know if anything else will store to
// that address before we can load from it. To prevent this situation, we need
// to insert our load, L, into the chain as a peer of O. To do this, we give L
// the same chain operand as O, we create a token factor from the chain results
// of O and L, and we replace all uses of O's chain result with that token
// factor (see spliceIntoChain below for this last part).
bool PPCTargetLowering::canReuseLoadAddress(SDValue Op, EVT MemVT,
ReuseLoadInfo &RLI,
SelectionDAG &DAG,
ISD::LoadExtType ET) const {
// Conservatively skip reusing for constrained FP nodes.
if (Op->isStrictFPOpcode())
return false;
SDLoc dl(Op);
bool ValidFPToUint = Op.getOpcode() == ISD::FP_TO_UINT &&
(Subtarget.hasFPCVT() || Op.getValueType() == MVT::i32);
if (ET == ISD::NON_EXTLOAD &&
(ValidFPToUint || Op.getOpcode() == ISD::FP_TO_SINT) &&
isOperationLegalOrCustom(Op.getOpcode(),
Op.getOperand(0).getValueType())) {
LowerFP_TO_INTForReuse(Op, RLI, DAG, dl);
return true;
}
LoadSDNode *LD = dyn_cast<LoadSDNode>(Op);
if (!LD || LD->getExtensionType() != ET || LD->isVolatile() ||
LD->isNonTemporal())
return false;
if (LD->getMemoryVT() != MemVT)
return false;
// If the result of the load is an illegal type, then we can't build a
// valid chain for reuse since the legalised loads and token factor node that
// ties the legalised loads together uses a different output chain then the
// illegal load.
if (!isTypeLegal(LD->getValueType(0)))
return false;
RLI.Ptr = LD->getBasePtr();
if (LD->isIndexed() && !LD->getOffset().isUndef()) {
assert(LD->getAddressingMode() == ISD::PRE_INC &&
"Non-pre-inc AM on PPC?");
RLI.Ptr = DAG.getNode(ISD::ADD, dl, RLI.Ptr.getValueType(), RLI.Ptr,
LD->getOffset());
}
RLI.Chain = LD->getChain();
RLI.MPI = LD->getPointerInfo();
RLI.IsDereferenceable = LD->isDereferenceable();
RLI.IsInvariant = LD->isInvariant();
RLI.Alignment = LD->getAlign();
RLI.AAInfo = LD->getAAInfo();
RLI.Ranges = LD->getRanges();
RLI.ResChain = SDValue(LD, LD->isIndexed() ? 2 : 1);
return true;
}
// Given the head of the old chain, ResChain, insert a token factor containing
// it and NewResChain, and make users of ResChain now be users of that token
// factor.
// TODO: Remove and use DAG::makeEquivalentMemoryOrdering() instead.
void PPCTargetLowering::spliceIntoChain(SDValue ResChain,
SDValue NewResChain,
SelectionDAG &DAG) const {
if (!ResChain)
return;
SDLoc dl(NewResChain);
SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
NewResChain, DAG.getUNDEF(MVT::Other));
assert(TF.getNode() != NewResChain.getNode() &&
"A new TF really is required here");
DAG.ReplaceAllUsesOfValueWith(ResChain, TF);
DAG.UpdateNodeOperands(TF.getNode(), ResChain, NewResChain);
}
/// Analyze profitability of direct move
/// prefer float load to int load plus direct move
/// when there is no integer use of int load
bool PPCTargetLowering::directMoveIsProfitable(const SDValue &Op) const {
SDNode *Origin = Op.getOperand(0).getNode();
if (Origin->getOpcode() != ISD::LOAD)
return true;
// If there is no LXSIBZX/LXSIHZX, like Power8,
// prefer direct move if the memory size is 1 or 2 bytes.
MachineMemOperand *MMO = cast<LoadSDNode>(Origin)->getMemOperand();
if (!Subtarget.hasP9Vector() && MMO->getSize() <= 2)
return true;
for (SDNode::use_iterator UI = Origin->use_begin(),
UE = Origin->use_end();
UI != UE; ++UI) {
// Only look at the users of the loaded value.
if (UI.getUse().get().getResNo() != 0)
continue;
if (UI->getOpcode() != ISD::SINT_TO_FP &&
UI->getOpcode() != ISD::UINT_TO_FP &&
UI->getOpcode() != ISD::STRICT_SINT_TO_FP &&
UI->getOpcode() != ISD::STRICT_UINT_TO_FP)
return true;
}
return false;
}
static SDValue convertIntToFP(SDValue Op, SDValue Src, SelectionDAG &DAG,
const PPCSubtarget &Subtarget,
SDValue Chain = SDValue()) {
bool IsSigned = Op.getOpcode() == ISD::SINT_TO_FP ||
Op.getOpcode() == ISD::STRICT_SINT_TO_FP;
SDLoc dl(Op);
// TODO: Any other flags to propagate?
SDNodeFlags Flags;
Flags.setNoFPExcept(Op->getFlags().hasNoFPExcept());
// If we have FCFIDS, then use it when converting to single-precision.
// Otherwise, convert to double-precision and then round.
bool IsSingle = Op.getValueType() == MVT::f32 && Subtarget.hasFPCVT();
unsigned ConvOpc = IsSingle ? (IsSigned ? PPCISD::FCFIDS : PPCISD::FCFIDUS)
: (IsSigned ? PPCISD::FCFID : PPCISD::FCFIDU);
EVT ConvTy = IsSingle ? MVT::f32 : MVT::f64;
if (Op->isStrictFPOpcode()) {
if (!Chain)
Chain = Op.getOperand(0);
return DAG.getNode(getPPCStrictOpcode(ConvOpc), dl,
DAG.getVTList(ConvTy, MVT::Other), {Chain, Src}, Flags);
} else
return DAG.getNode(ConvOpc, dl, ConvTy, Src);
}
/// Custom lowers integer to floating point conversions to use
/// the direct move instructions available in ISA 2.07 to avoid the
/// need for load/store combinations.
SDValue PPCTargetLowering::LowerINT_TO_FPDirectMove(SDValue Op,
SelectionDAG &DAG,
const SDLoc &dl) const {
assert((Op.getValueType() == MVT::f32 ||
Op.getValueType() == MVT::f64) &&
"Invalid floating point type as target of conversion");
assert(Subtarget.hasFPCVT() &&
"Int to FP conversions with direct moves require FPCVT");
SDValue Src = Op.getOperand(Op->isStrictFPOpcode() ? 1 : 0);
bool WordInt = Src.getSimpleValueType().SimpleTy == MVT::i32;
bool Signed = Op.getOpcode() == ISD::SINT_TO_FP ||
Op.getOpcode() == ISD::STRICT_SINT_TO_FP;
unsigned MovOpc = (WordInt && !Signed) ? PPCISD::MTVSRZ : PPCISD::MTVSRA;
SDValue Mov = DAG.getNode(MovOpc, dl, MVT::f64, Src);
return convertIntToFP(Op, Mov, DAG, Subtarget);
}
static SDValue widenVec(SelectionDAG &DAG, SDValue Vec, const SDLoc &dl) {
EVT VecVT = Vec.getValueType();
assert(VecVT.isVector() && "Expected a vector type.");
assert(VecVT.getSizeInBits() < 128 && "Vector is already full width.");
EVT EltVT = VecVT.getVectorElementType();
unsigned WideNumElts = 128 / EltVT.getSizeInBits();
EVT WideVT = EVT::getVectorVT(*DAG.getContext(), EltVT, WideNumElts);
unsigned NumConcat = WideNumElts / VecVT.getVectorNumElements();
SmallVector<SDValue, 16> Ops(NumConcat);
Ops[0] = Vec;
SDValue UndefVec = DAG.getUNDEF(VecVT);
for (unsigned i = 1; i < NumConcat; ++i)
Ops[i] = UndefVec;
return DAG.getNode(ISD::CONCAT_VECTORS, dl, WideVT, Ops);
}
SDValue PPCTargetLowering::LowerINT_TO_FPVector(SDValue Op, SelectionDAG &DAG,
const SDLoc &dl) const {
bool IsStrict = Op->isStrictFPOpcode();
unsigned Opc = Op.getOpcode();
SDValue Src = Op.getOperand(IsStrict ? 1 : 0);
assert((Opc == ISD::UINT_TO_FP || Opc == ISD::SINT_TO_FP ||
Opc == ISD::STRICT_UINT_TO_FP || Opc == ISD::STRICT_SINT_TO_FP) &&
"Unexpected conversion type");
assert((Op.getValueType() == MVT::v2f64 || Op.getValueType() == MVT::v4f32) &&
"Supports conversions to v2f64/v4f32 only.");
// TODO: Any other flags to propagate?
SDNodeFlags Flags;
Flags.setNoFPExcept(Op->getFlags().hasNoFPExcept());
bool SignedConv = Opc == ISD::SINT_TO_FP || Opc == ISD::STRICT_SINT_TO_FP;
bool FourEltRes = Op.getValueType() == MVT::v4f32;
SDValue Wide = widenVec(DAG, Src, dl);
EVT WideVT = Wide.getValueType();
unsigned WideNumElts = WideVT.getVectorNumElements();
MVT IntermediateVT = FourEltRes ? MVT::v4i32 : MVT::v2i64;
SmallVector<int, 16> ShuffV;
for (unsigned i = 0; i < WideNumElts; ++i)
ShuffV.push_back(i + WideNumElts);
int Stride = FourEltRes ? WideNumElts / 4 : WideNumElts / 2;
int SaveElts = FourEltRes ? 4 : 2;
if (Subtarget.isLittleEndian())
for (int i = 0; i < SaveElts; i++)
ShuffV[i * Stride] = i;
else
for (int i = 1; i <= SaveElts; i++)
ShuffV[i * Stride - 1] = i - 1;
SDValue ShuffleSrc2 =
SignedConv ? DAG.getUNDEF(WideVT) : DAG.getConstant(0, dl, WideVT);
SDValue Arrange = DAG.getVectorShuffle(WideVT, dl, Wide, ShuffleSrc2, ShuffV);
SDValue Extend;
if (SignedConv) {
Arrange = DAG.getBitcast(IntermediateVT, Arrange);
EVT ExtVT = Src.getValueType();
if (Subtarget.hasP9Altivec())
ExtVT = EVT::getVectorVT(*DAG.getContext(), WideVT.getVectorElementType(),
IntermediateVT.getVectorNumElements());
Extend = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, IntermediateVT, Arrange,
DAG.getValueType(ExtVT));
} else
Extend = DAG.getNode(ISD::BITCAST, dl, IntermediateVT, Arrange);
if (IsStrict)
return DAG.getNode(Opc, dl, DAG.getVTList(Op.getValueType(), MVT::Other),
{Op.getOperand(0), Extend}, Flags);
return DAG.getNode(Opc, dl, Op.getValueType(), Extend);
}
SDValue PPCTargetLowering::LowerINT_TO_FP(SDValue Op,
SelectionDAG &DAG) const {
SDLoc dl(Op);
bool IsSigned = Op.getOpcode() == ISD::SINT_TO_FP ||
Op.getOpcode() == ISD::STRICT_SINT_TO_FP;
bool IsStrict = Op->isStrictFPOpcode();
SDValue Src = Op.getOperand(IsStrict ? 1 : 0);
SDValue Chain = IsStrict ? Op.getOperand(0) : DAG.getEntryNode();
// TODO: Any other flags to propagate?
SDNodeFlags Flags;
Flags.setNoFPExcept(Op->getFlags().hasNoFPExcept());
EVT InVT = Src.getValueType();
EVT OutVT = Op.getValueType();
if (OutVT.isVector() && OutVT.isFloatingPoint() &&
isOperationCustom(Op.getOpcode(), InVT))
return LowerINT_TO_FPVector(Op, DAG, dl);
// Conversions to f128 are legal.
if (Op.getValueType() == MVT::f128)
return Subtarget.hasP9Vector() ? Op : SDValue();
// Don't handle ppc_fp128 here; let it be lowered to a libcall.
if (Op.getValueType() != MVT::f32 && Op.getValueType() != MVT::f64)
return SDValue();
if (Src.getValueType() == MVT::i1) {
SDValue Sel = DAG.getNode(ISD::SELECT, dl, Op.getValueType(), Src,
DAG.getConstantFP(1.0, dl, Op.getValueType()),
DAG.getConstantFP(0.0, dl, Op.getValueType()));
if (IsStrict)
return DAG.getMergeValues({Sel, Chain}, dl);
else
return Sel;
}
// If we have direct moves, we can do all the conversion, skip the store/load
// however, without FPCVT we can't do most conversions.
if (Subtarget.hasDirectMove() && directMoveIsProfitable(Op) &&
Subtarget.isPPC64() && Subtarget.hasFPCVT())
return LowerINT_TO_FPDirectMove(Op, DAG, dl);
assert((IsSigned || Subtarget.hasFPCVT()) &&
"UINT_TO_FP is supported only with FPCVT");
if (Src.getValueType() == MVT::i64) {
SDValue SINT = Src;
// When converting to single-precision, we actually need to convert
// to double-precision first and then round to single-precision.
// To avoid double-rounding effects during that operation, we have
// to prepare the input operand. Bits that might be truncated when
// converting to double-precision are replaced by a bit that won't
// be lost at this stage, but is below the single-precision rounding
// position.
//
// However, if -enable-unsafe-fp-math is in effect, accept double
// rounding to avoid the extra overhead.
if (Op.getValueType() == MVT::f32 &&
!Subtarget.hasFPCVT() &&
!DAG.getTarget().Options.UnsafeFPMath) {
// Twiddle input to make sure the low 11 bits are zero. (If this
// is the case, we are guaranteed the value will fit into the 53 bit
// mantissa of an IEEE double-precision value without rounding.)
// If any of those low 11 bits were not zero originally, make sure
// bit 12 (value 2048) is set instead, so that the final rounding
// to single-precision gets the correct result.
SDValue Round = DAG.getNode(ISD::AND, dl, MVT::i64,
SINT, DAG.getConstant(2047, dl, MVT::i64));
Round = DAG.getNode(ISD::ADD, dl, MVT::i64,
Round, DAG.getConstant(2047, dl, MVT::i64));
Round = DAG.getNode(ISD::OR, dl, MVT::i64, Round, SINT);
Round = DAG.getNode(ISD::AND, dl, MVT::i64,
Round, DAG.getConstant(-2048, dl, MVT::i64));
// However, we cannot use that value unconditionally: if the magnitude
// of the input value is small, the bit-twiddling we did above might
// end up visibly changing the output. Fortunately, in that case, we
// don't need to twiddle bits since the original input will convert
// exactly to double-precision floating-point already. Therefore,
// construct a conditional to use the original value if the top 11
// bits are all sign-bit copies, and use the rounded value computed
// above otherwise.
SDValue Cond = DAG.getNode(ISD::SRA, dl, MVT::i64,
SINT, DAG.getConstant(53, dl, MVT::i32));
Cond = DAG.getNode(ISD::ADD, dl, MVT::i64,
Cond, DAG.getConstant(1, dl, MVT::i64));
Cond = DAG.getSetCC(
dl,
getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), MVT::i64),
Cond, DAG.getConstant(1, dl, MVT::i64), ISD::SETUGT);
SINT = DAG.getNode(ISD::SELECT, dl, MVT::i64, Cond, Round, SINT);
}
ReuseLoadInfo RLI;
SDValue Bits;
MachineFunction &MF = DAG.getMachineFunction();
if (canReuseLoadAddress(SINT, MVT::i64, RLI, DAG)) {
Bits = DAG.getLoad(MVT::f64, dl, RLI.Chain, RLI.Ptr, RLI.MPI,
RLI.Alignment, RLI.MMOFlags(), RLI.AAInfo, RLI.Ranges);
spliceIntoChain(RLI.ResChain, Bits.getValue(1), DAG);
} else if (Subtarget.hasLFIWAX() &&
canReuseLoadAddress(SINT, MVT::i32, RLI, DAG, ISD::SEXTLOAD)) {
MachineMemOperand *MMO =
MF.getMachineMemOperand(RLI.MPI, MachineMemOperand::MOLoad, 4,
RLI.Alignment, RLI.AAInfo, RLI.Ranges);
SDValue Ops[] = { RLI.Chain, RLI.Ptr };
Bits = DAG.getMemIntrinsicNode(PPCISD::LFIWAX, dl,
DAG.getVTList(MVT::f64, MVT::Other),
Ops, MVT::i32, MMO);
spliceIntoChain(RLI.ResChain, Bits.getValue(1), DAG);
} else if (Subtarget.hasFPCVT() &&
canReuseLoadAddress(SINT, MVT::i32, RLI, DAG, ISD::ZEXTLOAD)) {
MachineMemOperand *MMO =
MF.getMachineMemOperand(RLI.MPI, MachineMemOperand::MOLoad, 4,
RLI.Alignment, RLI.AAInfo, RLI.Ranges);
SDValue Ops[] = { RLI.Chain, RLI.Ptr };
Bits = DAG.getMemIntrinsicNode(PPCISD::LFIWZX, dl,
DAG.getVTList(MVT::f64, MVT::Other),
Ops, MVT::i32, MMO);
spliceIntoChain(RLI.ResChain, Bits.getValue(1), DAG);
} else if (((Subtarget.hasLFIWAX() &&
SINT.getOpcode() == ISD::SIGN_EXTEND) ||
(Subtarget.hasFPCVT() &&
SINT.getOpcode() == ISD::ZERO_EXTEND)) &&
SINT.getOperand(0).getValueType() == MVT::i32) {
MachineFrameInfo &MFI = MF.getFrameInfo();
EVT PtrVT = getPointerTy(DAG.getDataLayout());
int FrameIdx = MFI.CreateStackObject(4, Align(4), false);
SDValue FIdx = DAG.getFrameIndex(FrameIdx, PtrVT);
SDValue Store = DAG.getStore(Chain, dl, SINT.getOperand(0), FIdx,
MachinePointerInfo::getFixedStack(
DAG.getMachineFunction(), FrameIdx));
Chain = Store;
assert(cast<StoreSDNode>(Store)->getMemoryVT() == MVT::i32 &&
"Expected an i32 store");
RLI.Ptr = FIdx;
RLI.Chain = Chain;
RLI.MPI =
MachinePointerInfo::getFixedStack(DAG.getMachineFunction(), FrameIdx);
RLI.Alignment = Align(4);
MachineMemOperand *MMO =
MF.getMachineMemOperand(RLI.MPI, MachineMemOperand::MOLoad, 4,
RLI.Alignment, RLI.AAInfo, RLI.Ranges);
SDValue Ops[] = { RLI.Chain, RLI.Ptr };
Bits = DAG.getMemIntrinsicNode(SINT.getOpcode() == ISD::ZERO_EXTEND ?
PPCISD::LFIWZX : PPCISD::LFIWAX,
dl, DAG.getVTList(MVT::f64, MVT::Other),
Ops, MVT::i32, MMO);
Chain = Bits.getValue(1);
} else
Bits = DAG.getNode(ISD::BITCAST, dl, MVT::f64, SINT);
SDValue FP = convertIntToFP(Op, Bits, DAG, Subtarget, Chain);
if (IsStrict)
Chain = FP.getValue(1);
if (Op.getValueType() == MVT::f32 && !Subtarget.hasFPCVT()) {
if (IsStrict)
FP = DAG.getNode(ISD::STRICT_FP_ROUND, dl,
DAG.getVTList(MVT::f32, MVT::Other),
{Chain, FP, DAG.getIntPtrConstant(0, dl)}, Flags);
else
FP = DAG.getNode(ISD::FP_ROUND, dl, MVT::f32, FP,
DAG.getIntPtrConstant(0, dl));
}
return FP;
}
assert(Src.getValueType() == MVT::i32 &&
"Unhandled INT_TO_FP type in custom expander!");
// Since we only generate this in 64-bit mode, we can take advantage of
// 64-bit registers. In particular, sign extend the input value into the
// 64-bit register with extsw, store the WHOLE 64-bit value into the stack
// then lfd it and fcfid it.
MachineFunction &MF = DAG.getMachineFunction();
MachineFrameInfo &MFI = MF.getFrameInfo();
EVT PtrVT = getPointerTy(MF.getDataLayout());
SDValue Ld;
if (Subtarget.hasLFIWAX() || Subtarget.hasFPCVT()) {
ReuseLoadInfo RLI;
bool ReusingLoad;
if (!(ReusingLoad = canReuseLoadAddress(Src, MVT::i32, RLI, DAG))) {
int FrameIdx = MFI.CreateStackObject(4, Align(4), false);
SDValue FIdx = DAG.getFrameIndex(FrameIdx, PtrVT);
SDValue Store = DAG.getStore(Chain, dl, Src, FIdx,
MachinePointerInfo::getFixedStack(
DAG.getMachineFunction(), FrameIdx));
Chain = Store;
assert(cast<StoreSDNode>(Store)->getMemoryVT() == MVT::i32 &&
"Expected an i32 store");
RLI.Ptr = FIdx;
RLI.Chain = Chain;
RLI.MPI =
MachinePointerInfo::getFixedStack(DAG.getMachineFunction(), FrameIdx);
RLI.Alignment = Align(4);
}
MachineMemOperand *MMO =
MF.getMachineMemOperand(RLI.MPI, MachineMemOperand::MOLoad, 4,
RLI.Alignment, RLI.AAInfo, RLI.Ranges);
SDValue Ops[] = { RLI.Chain, RLI.Ptr };
Ld = DAG.getMemIntrinsicNode(IsSigned ? PPCISD::LFIWAX : PPCISD::LFIWZX, dl,
DAG.getVTList(MVT::f64, MVT::Other), Ops,
MVT::i32, MMO);
Chain = Ld.getValue(1);
if (ReusingLoad)
spliceIntoChain(RLI.ResChain, Ld.getValue(1), DAG);
} else {
assert(Subtarget.isPPC64() &&
"i32->FP without LFIWAX supported only on PPC64");
int FrameIdx = MFI.CreateStackObject(8, Align(8), false);
SDValue FIdx = DAG.getFrameIndex(FrameIdx, PtrVT);
SDValue Ext64 = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::i64, Src);
// STD the extended value into the stack slot.
SDValue Store = DAG.getStore(
Chain, dl, Ext64, FIdx,
MachinePointerInfo::getFixedStack(DAG.getMachineFunction(), FrameIdx));
Chain = Store;
// Load the value as a double.
Ld = DAG.getLoad(
MVT::f64, dl, Chain, FIdx,
MachinePointerInfo::getFixedStack(DAG.getMachineFunction(), FrameIdx));
Chain = Ld.getValue(1);
}
// FCFID it and return it.
SDValue FP = convertIntToFP(Op, Ld, DAG, Subtarget, Chain);
if (IsStrict)
Chain = FP.getValue(1);
if (Op.getValueType() == MVT::f32 && !Subtarget.hasFPCVT()) {
if (IsStrict)
FP = DAG.getNode(ISD::STRICT_FP_ROUND, dl,
DAG.getVTList(MVT::f32, MVT::Other),
{Chain, FP, DAG.getIntPtrConstant(0, dl)}, Flags);
else
FP = DAG.getNode(ISD::FP_ROUND, dl, MVT::f32, FP,
DAG.getIntPtrConstant(0, dl));
}
return FP;
}
SDValue PPCTargetLowering::LowerFLT_ROUNDS_(SDValue Op,
SelectionDAG &DAG) const {
SDLoc dl(Op);
/*
The rounding mode is in bits 30:31 of FPSR, and has the following
settings:
00 Round to nearest
01 Round to 0
10 Round to +inf
11 Round to -inf
FLT_ROUNDS, on the other hand, expects the following:
-1 Undefined
0 Round to 0
1 Round to nearest
2 Round to +inf
3 Round to -inf
To perform the conversion, we do:
((FPSCR & 0x3) ^ ((~FPSCR & 0x3) >> 1))
*/
MachineFunction &MF = DAG.getMachineFunction();
EVT VT = Op.getValueType();
EVT PtrVT = getPointerTy(MF.getDataLayout());
// Save FP Control Word to register
SDValue Chain = Op.getOperand(0);
SDValue MFFS = DAG.getNode(PPCISD::MFFS, dl, {MVT::f64, MVT::Other}, Chain);
Chain = MFFS.getValue(1);
SDValue CWD;
if (isTypeLegal(MVT::i64)) {
CWD = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32,
DAG.getNode(ISD::BITCAST, dl, MVT::i64, MFFS));
} else {
// Save FP register to stack slot
int SSFI = MF.getFrameInfo().CreateStackObject(8, Align(8), false);
SDValue StackSlot = DAG.getFrameIndex(SSFI, PtrVT);
Chain = DAG.getStore(Chain, dl, MFFS, StackSlot, MachinePointerInfo());
// Load FP Control Word from low 32 bits of stack slot.
assert(hasBigEndianPartOrdering(MVT::i64, MF.getDataLayout()) &&
"Stack slot adjustment is valid only on big endian subtargets!");
SDValue Four = DAG.getConstant(4, dl, PtrVT);
SDValue Addr = DAG.getNode(ISD::ADD, dl, PtrVT, StackSlot, Four);
CWD = DAG.getLoad(MVT::i32, dl, Chain, Addr, MachinePointerInfo());
Chain = CWD.getValue(1);
}
// Transform as necessary
SDValue CWD1 =
DAG.getNode(ISD::AND, dl, MVT::i32,
CWD, DAG.getConstant(3, dl, MVT::i32));
SDValue CWD2 =
DAG.getNode(ISD::SRL, dl, MVT::i32,
DAG.getNode(ISD::AND, dl, MVT::i32,
DAG.getNode(ISD::XOR, dl, MVT::i32,
CWD, DAG.getConstant(3, dl, MVT::i32)),
DAG.getConstant(3, dl, MVT::i32)),
DAG.getConstant(1, dl, MVT::i32));
SDValue RetVal =
DAG.getNode(ISD::XOR, dl, MVT::i32, CWD1, CWD2);
RetVal =
DAG.getNode((VT.getSizeInBits() < 16 ? ISD::TRUNCATE : ISD::ZERO_EXTEND),
dl, VT, RetVal);
return DAG.getMergeValues({RetVal, Chain}, dl);
}
SDValue PPCTargetLowering::LowerSHL_PARTS(SDValue Op, SelectionDAG &DAG) const {
EVT VT = Op.getValueType();
unsigned BitWidth = VT.getSizeInBits();
SDLoc dl(Op);
assert(Op.getNumOperands() == 3 &&
VT == Op.getOperand(1).getValueType() &&
"Unexpected SHL!");
// Expand into a bunch of logical ops. Note that these ops
// depend on the PPC behavior for oversized shift amounts.
SDValue Lo = Op.getOperand(0);
SDValue Hi = Op.getOperand(1);
SDValue Amt = Op.getOperand(2);
EVT AmtVT = Amt.getValueType();
SDValue Tmp1 = DAG.getNode(ISD::SUB, dl, AmtVT,
DAG.getConstant(BitWidth, dl, AmtVT), Amt);
SDValue Tmp2 = DAG.getNode(PPCISD::SHL, dl, VT, Hi, Amt);
SDValue Tmp3 = DAG.getNode(PPCISD::SRL, dl, VT, Lo, Tmp1);
SDValue Tmp4 = DAG.getNode(ISD::OR , dl, VT, Tmp2, Tmp3);
SDValue Tmp5 = DAG.getNode(ISD::ADD, dl, AmtVT, Amt,
DAG.getConstant(-BitWidth, dl, AmtVT));
SDValue Tmp6 = DAG.getNode(PPCISD::SHL, dl, VT, Lo, Tmp5);
SDValue OutHi = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp6);
SDValue OutLo = DAG.getNode(PPCISD::SHL, dl, VT, Lo, Amt);
SDValue OutOps[] = { OutLo, OutHi };
return DAG.getMergeValues(OutOps, dl);
}
SDValue PPCTargetLowering::LowerSRL_PARTS(SDValue Op, SelectionDAG &DAG) const {
EVT VT = Op.getValueType();
SDLoc dl(Op);
unsigned BitWidth = VT.getSizeInBits();
assert(Op.getNumOperands() == 3 &&
VT == Op.getOperand(1).getValueType() &&
"Unexpected SRL!");
// Expand into a bunch of logical ops. Note that these ops
// depend on the PPC behavior for oversized shift amounts.
SDValue Lo = Op.getOperand(0);
SDValue Hi = Op.getOperand(1);
SDValue Amt = Op.getOperand(2);
EVT AmtVT = Amt.getValueType();
SDValue Tmp1 = DAG.getNode(ISD::SUB, dl, AmtVT,
DAG.getConstant(BitWidth, dl, AmtVT), Amt);
SDValue Tmp2 = DAG.getNode(PPCISD::SRL, dl, VT, Lo, Amt);
SDValue Tmp3 = DAG.getNode(PPCISD::SHL, dl, VT, Hi, Tmp1);
SDValue Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp3);
SDValue Tmp5 = DAG.getNode(ISD::ADD, dl, AmtVT, Amt,
DAG.getConstant(-BitWidth, dl, AmtVT));
SDValue Tmp6 = DAG.getNode(PPCISD::SRL, dl, VT, Hi, Tmp5);
SDValue OutLo = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp6);
SDValue OutHi = DAG.getNode(PPCISD::SRL, dl, VT, Hi, Amt);
SDValue OutOps[] = { OutLo, OutHi };
return DAG.getMergeValues(OutOps, dl);
}
SDValue PPCTargetLowering::LowerSRA_PARTS(SDValue Op, SelectionDAG &DAG) const {
SDLoc dl(Op);
EVT VT = Op.getValueType();
unsigned BitWidth = VT.getSizeInBits();
assert(Op.getNumOperands() == 3 &&
VT == Op.getOperand(1).getValueType() &&
"Unexpected SRA!");
// Expand into a bunch of logical ops, followed by a select_cc.
SDValue Lo = Op.getOperand(0);
SDValue Hi = Op.getOperand(1);
SDValue Amt = Op.getOperand(2);
EVT AmtVT = Amt.getValueType();
SDValue Tmp1 = DAG.getNode(ISD::SUB, dl, AmtVT,
DAG.getConstant(BitWidth, dl, AmtVT), Amt);
SDValue Tmp2 = DAG.getNode(PPCISD::SRL, dl, VT, Lo, Amt);
SDValue Tmp3 = DAG.getNode(PPCISD::SHL, dl, VT, Hi, Tmp1);
SDValue Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp3);
SDValue Tmp5 = DAG.getNode(ISD::ADD, dl, AmtVT, Amt,
DAG.getConstant(-BitWidth, dl, AmtVT));
SDValue Tmp6 = DAG.getNode(PPCISD::SRA, dl, VT, Hi, Tmp5);
SDValue OutHi = DAG.getNode(PPCISD::SRA, dl, VT, Hi, Amt);
SDValue OutLo = DAG.getSelectCC(dl, Tmp5, DAG.getConstant(0, dl, AmtVT),
Tmp4, Tmp6, ISD::SETLE);
SDValue OutOps[] = { OutLo, OutHi };
return DAG.getMergeValues(OutOps, dl);
}
SDValue PPCTargetLowering::LowerFunnelShift(SDValue Op,
SelectionDAG &DAG) const {
SDLoc dl(Op);
EVT VT = Op.getValueType();
unsigned BitWidth = VT.getSizeInBits();
bool IsFSHL = Op.getOpcode() == ISD::FSHL;
SDValue X = Op.getOperand(0);
SDValue Y = Op.getOperand(1);
SDValue Z = Op.getOperand(2);
EVT AmtVT = Z.getValueType();
// fshl: (X << (Z % BW)) | (Y >> (BW - (Z % BW)))
// fshr: (X << (BW - (Z % BW))) | (Y >> (Z % BW))
// This is simpler than TargetLowering::expandFunnelShift because we can rely
// on PowerPC shift by BW being well defined.
Z = DAG.getNode(ISD::AND, dl, AmtVT, Z,
DAG.getConstant(BitWidth - 1, dl, AmtVT));
SDValue SubZ =
DAG.getNode(ISD::SUB, dl, AmtVT, DAG.getConstant(BitWidth, dl, AmtVT), Z);
X = DAG.getNode(PPCISD::SHL, dl, VT, X, IsFSHL ? Z : SubZ);
Y = DAG.getNode(PPCISD::SRL, dl, VT, Y, IsFSHL ? SubZ : Z);
return DAG.getNode(ISD::OR, dl, VT, X, Y);
}
//===----------------------------------------------------------------------===//
// Vector related lowering.
//
/// getCanonicalConstSplat - Build a canonical splat immediate of Val with an
/// element size of SplatSize. Cast the result to VT.
static SDValue getCanonicalConstSplat(uint64_t Val, unsigned SplatSize, EVT VT,
SelectionDAG &DAG, const SDLoc &dl) {
static const MVT VTys[] = { // canonical VT to use for each size.
MVT::v16i8, MVT::v8i16, MVT::Other, MVT::v4i32
};
EVT ReqVT = VT != MVT::Other ? VT : VTys[SplatSize-1];
// For a splat with all ones, turn it to vspltisb 0xFF to canonicalize.
if (Val == ((1LLU << (SplatSize * 8)) - 1)) {
SplatSize = 1;
Val = 0xFF;
}
EVT CanonicalVT = VTys[SplatSize-1];
// Build a canonical splat for this value.
return DAG.getBitcast(ReqVT, DAG.getConstant(Val, dl, CanonicalVT));
}
/// BuildIntrinsicOp - Return a unary operator intrinsic node with the
/// specified intrinsic ID.
static SDValue BuildIntrinsicOp(unsigned IID, SDValue Op, SelectionDAG &DAG,
const SDLoc &dl, EVT DestVT = MVT::Other) {
if (DestVT == MVT::Other) DestVT = Op.getValueType();
return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, DestVT,
DAG.getConstant(IID, dl, MVT::i32), Op);
}
/// BuildIntrinsicOp - Return a binary operator intrinsic node with the
/// specified intrinsic ID.
static SDValue BuildIntrinsicOp(unsigned IID, SDValue LHS, SDValue RHS,
SelectionDAG &DAG, const SDLoc &dl,
EVT DestVT = MVT::Other) {
if (DestVT == MVT::Other) DestVT = LHS.getValueType();
return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, DestVT,
DAG.getConstant(IID, dl, MVT::i32), LHS, RHS);
}
/// BuildIntrinsicOp - Return a ternary operator intrinsic node with the
/// specified intrinsic ID.
static SDValue BuildIntrinsicOp(unsigned IID, SDValue Op0, SDValue Op1,
SDValue Op2, SelectionDAG &DAG, const SDLoc &dl,
EVT DestVT = MVT::Other) {
if (DestVT == MVT::Other) DestVT = Op0.getValueType();
return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, DestVT,
DAG.getConstant(IID, dl, MVT::i32), Op0, Op1, Op2);
}
/// BuildVSLDOI - Return a VECTOR_SHUFFLE that is a vsldoi of the specified
/// amount. The result has the specified value type.
static SDValue BuildVSLDOI(SDValue LHS, SDValue RHS, unsigned Amt, EVT VT,
SelectionDAG &DAG, const SDLoc &dl) {
// Force LHS/RHS to be the right type.
LHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, LHS);
RHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, RHS);
int Ops[16];
for (unsigned i = 0; i != 16; ++i)
Ops[i] = i + Amt;
SDValue T = DAG.getVectorShuffle(MVT::v16i8, dl, LHS, RHS, Ops);
return DAG.getNode(ISD::BITCAST, dl, VT, T);
}
/// Do we have an efficient pattern in a .td file for this node?
///
/// \param V - pointer to the BuildVectorSDNode being matched
/// \param HasDirectMove - does this subtarget have VSR <-> GPR direct moves?
///
/// There are some patterns where it is beneficial to keep a BUILD_VECTOR
/// node as a BUILD_VECTOR node rather than expanding it. The patterns where
/// the opposite is true (expansion is beneficial) are:
/// - The node builds a vector out of integers that are not 32 or 64-bits
/// - The node builds a vector out of constants
/// - The node is a "load-and-splat"
/// In all other cases, we will choose to keep the BUILD_VECTOR.
static bool haveEfficientBuildVectorPattern(BuildVectorSDNode *V,
bool HasDirectMove,
bool HasP8Vector) {
EVT VecVT = V->getValueType(0);
bool RightType = VecVT == MVT::v2f64 ||
(HasP8Vector && VecVT == MVT::v4f32) ||
(HasDirectMove && (VecVT == MVT::v2i64 || VecVT == MVT::v4i32));
if (!RightType)
return false;
bool IsSplat = true;
bool IsLoad = false;
SDValue Op0 = V->getOperand(0);
// This function is called in a block that confirms the node is not a constant
// splat. So a constant BUILD_VECTOR here means the vector is built out of
// different constants.
if (V->isConstant())
return false;
for (int i = 0, e = V->getNumOperands(); i < e; ++i) {
if (V->getOperand(i).isUndef())
return false;
// We want to expand nodes that represent load-and-splat even if the
// loaded value is a floating point truncation or conversion to int.
if (V->getOperand(i).getOpcode() == ISD::LOAD ||
(V->getOperand(i).getOpcode() == ISD::FP_ROUND &&
V->getOperand(i).getOperand(0).getOpcode() == ISD::LOAD) ||
(V->getOperand(i).getOpcode() == ISD::FP_TO_SINT &&
V->getOperand(i).getOperand(0).getOpcode() == ISD::LOAD) ||
(V->getOperand(i).getOpcode() == ISD::FP_TO_UINT &&
V->getOperand(i).getOperand(0).getOpcode() == ISD::LOAD))
IsLoad = true;
// If the operands are different or the input is not a load and has more
// uses than just this BV node, then it isn't a splat.
if (V->getOperand(i) != Op0 ||
(!IsLoad && !V->isOnlyUserOf(V->getOperand(i).getNode())))
IsSplat = false;
}
return !(IsSplat && IsLoad);
}
// Lower BITCAST(f128, (build_pair i64, i64)) to BUILD_FP128.
SDValue PPCTargetLowering::LowerBITCAST(SDValue Op, SelectionDAG &DAG) const {
SDLoc dl(Op);
SDValue Op0 = Op->getOperand(0);
if ((Op.getValueType() != MVT::f128) ||
(Op0.getOpcode() != ISD::BUILD_PAIR) ||
(Op0.getOperand(0).getValueType() != MVT::i64) ||
(Op0.getOperand(1).getValueType() != MVT::i64))
return SDValue();
return DAG.getNode(PPCISD::BUILD_FP128, dl, MVT::f128, Op0.getOperand(0),
Op0.getOperand(1));
}
static const SDValue *getNormalLoadInput(const SDValue &Op, bool &IsPermuted) {
const SDValue *InputLoad = &Op;
if (InputLoad->getOpcode() == ISD::BITCAST)
InputLoad = &InputLoad->getOperand(0);
if (InputLoad->getOpcode() == ISD::SCALAR_TO_VECTOR ||
InputLoad->getOpcode() == PPCISD::SCALAR_TO_VECTOR_PERMUTED) {
IsPermuted = InputLoad->getOpcode() == PPCISD::SCALAR_TO_VECTOR_PERMUTED;
InputLoad = &InputLoad->getOperand(0);
}
if (InputLoad->getOpcode() != ISD::LOAD)
return nullptr;
LoadSDNode *LD = cast<LoadSDNode>(*InputLoad);
return ISD::isNormalLoad(LD) ? InputLoad : nullptr;
}
// Convert the argument APFloat to a single precision APFloat if there is no
// loss in information during the conversion to single precision APFloat and the
// resulting number is not a denormal number. Return true if successful.
bool llvm::convertToNonDenormSingle(APFloat &ArgAPFloat) {
APFloat APFloatToConvert = ArgAPFloat;
bool LosesInfo = true;
APFloatToConvert.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
&LosesInfo);
bool Success = (!LosesInfo && !APFloatToConvert.isDenormal());
if (Success)
ArgAPFloat = APFloatToConvert;
return Success;
}
// Bitcast the argument APInt to a double and convert it to a single precision
// APFloat, bitcast the APFloat to an APInt and assign it to the original
// argument if there is no loss in information during the conversion from
// double to single precision APFloat and the resulting number is not a denormal
// number. Return true if successful.
bool llvm::convertToNonDenormSingle(APInt &ArgAPInt) {
double DpValue = ArgAPInt.bitsToDouble();
APFloat APFloatDp(DpValue);
bool Success = convertToNonDenormSingle(APFloatDp);
if (Success)
ArgAPInt = APFloatDp.bitcastToAPInt();
return Success;
}
// Nondestructive check for convertTonNonDenormSingle.
bool llvm::checkConvertToNonDenormSingle(APFloat &ArgAPFloat) {
// Only convert if it loses info, since XXSPLTIDP should
// handle the other case.
APFloat APFloatToConvert = ArgAPFloat;
bool LosesInfo = true;
APFloatToConvert.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
&LosesInfo);
return (!LosesInfo && !APFloatToConvert.isDenormal());
}
static bool isValidSplatLoad(const PPCSubtarget &Subtarget, const SDValue &Op,
unsigned &Opcode) {
LoadSDNode *InputNode = dyn_cast<LoadSDNode>(Op.getOperand(0));
if (!InputNode || !Subtarget.hasVSX() || !ISD::isUNINDEXEDLoad(InputNode))
return false;
EVT Ty = Op->getValueType(0);
// For v2f64, v4f32 and v4i32 types, we require the load to be non-extending
// as we cannot handle extending loads for these types.
if ((Ty == MVT::v2f64 || Ty == MVT::v4f32 || Ty == MVT::v4i32) &&
ISD::isNON_EXTLoad(InputNode))
return true;
EVT MemVT = InputNode->getMemoryVT();
// For v8i16 and v16i8 types, extending loads can be handled as long as the
// memory VT is the same vector element VT type.
// The loads feeding into the v8i16 and v16i8 types will be extending because
// scalar i8/i16 are not legal types.
if ((Ty == MVT::v8i16 || Ty == MVT::v16i8) && ISD::isEXTLoad(InputNode) &&
(MemVT == Ty.getVectorElementType()))
return true;
if (Ty == MVT::v2i64) {
// Check the extend type, when the input type is i32, and the output vector
// type is v2i64.
if (MemVT == MVT::i32) {
if (ISD::isZEXTLoad(InputNode))
Opcode = PPCISD::ZEXT_LD_SPLAT;
if (ISD::isSEXTLoad(InputNode))
Opcode = PPCISD::SEXT_LD_SPLAT;
}
return true;
}
return false;
}
// If this is a case we can't handle, return null and let the default
// expansion code take care of it. If we CAN select this case, and if it
// selects to a single instruction, return Op. Otherwise, if we can codegen
// this case more efficiently than a constant pool load, lower it to the
// sequence of ops that should be used.
SDValue PPCTargetLowering::LowerBUILD_VECTOR(SDValue Op,
SelectionDAG &DAG) const {
SDLoc dl(Op);
BuildVectorSDNode *BVN = dyn_cast<BuildVectorSDNode>(Op.getNode());
assert(BVN && "Expected a BuildVectorSDNode in LowerBUILD_VECTOR");
// Check if this is a splat of a constant value.
APInt APSplatBits, APSplatUndef;
unsigned SplatBitSize;
bool HasAnyUndefs;
bool BVNIsConstantSplat =
BVN->isConstantSplat(APSplatBits, APSplatUndef, SplatBitSize,
HasAnyUndefs, 0, !Subtarget.isLittleEndian());
// If it is a splat of a double, check if we can shrink it to a 32 bit
// non-denormal float which when converted back to double gives us the same
// double. This is to exploit the XXSPLTIDP instruction.
// If we lose precision, we use XXSPLTI32DX.
if (BVNIsConstantSplat && (SplatBitSize == 64) &&
Subtarget.hasPrefixInstrs()) {
// Check the type first to short-circuit so we don't modify APSplatBits if
// this block isn't executed.
if ((Op->getValueType(0) == MVT::v2f64) &&
convertToNonDenormSingle(APSplatBits)) {
SDValue SplatNode = DAG.getNode(
PPCISD::XXSPLTI_SP_TO_DP, dl, MVT::v2f64,
DAG.getTargetConstant(APSplatBits.getZExtValue(), dl, MVT::i32));
return DAG.getBitcast(Op.getValueType(), SplatNode);
} else {
// We may lose precision, so we have to use XXSPLTI32DX.
uint32_t Hi =
(uint32_t)((APSplatBits.getZExtValue() & 0xFFFFFFFF00000000LL) >> 32);
uint32_t Lo =
(uint32_t)(APSplatBits.getZExtValue() & 0xFFFFFFFF);
SDValue SplatNode = DAG.getUNDEF(MVT::v2i64);
if (!Hi || !Lo)
// If either load is 0, then we should generate XXLXOR to set to 0.
SplatNode = DAG.getTargetConstant(0, dl, MVT::v2i64);
if (Hi)
SplatNode = DAG.getNode(
PPCISD::XXSPLTI32DX, dl, MVT::v2i64, SplatNode,
DAG.getTargetConstant(0, dl, MVT::i32),
DAG.getTargetConstant(Hi, dl, MVT::i32));
if (Lo)
SplatNode =
DAG.getNode(PPCISD::XXSPLTI32DX, dl, MVT::v2i64, SplatNode,
DAG.getTargetConstant(1, dl, MVT::i32),
DAG.getTargetConstant(Lo, dl, MVT::i32));
return DAG.getBitcast(Op.getValueType(), SplatNode);
}
}
if (!BVNIsConstantSplat || SplatBitSize > 32) {
unsigned NewOpcode = PPCISD::LD_SPLAT;
// Handle load-and-splat patterns as we have instructions that will do this
// in one go.
if (DAG.isSplatValue(Op, true) &&
isValidSplatLoad(Subtarget, Op, NewOpcode)) {
const SDValue *InputLoad = &Op.getOperand(0);
LoadSDNode *LD = cast<LoadSDNode>(*InputLoad);
// If the input load is an extending load, it will be an i32 -> i64
// extending load and isValidSplatLoad() will update NewOpcode.
unsigned MemorySize = LD->getMemoryVT().getScalarSizeInBits();
unsigned ElementSize =
MemorySize * ((NewOpcode == PPCISD::LD_SPLAT) ? 1 : 2);
assert(((ElementSize == 2 * MemorySize)
? (NewOpcode == PPCISD::ZEXT_LD_SPLAT ||
NewOpcode == PPCISD::SEXT_LD_SPLAT)
: (NewOpcode == PPCISD::LD_SPLAT)) &&
"Unmatched element size and opcode!\n");
// Checking for a single use of this load, we have to check for vector
// width (128 bits) / ElementSize uses (since each operand of the
// BUILD_VECTOR is a separate use of the value.
unsigned NumUsesOfInputLD = 128 / ElementSize;
for (SDValue BVInOp : Op->ops())
if (BVInOp.isUndef())
NumUsesOfInputLD--;
// Exclude somes case where LD_SPLAT is worse than scalar_to_vector:
// Below cases should also happen for "lfiwzx/lfiwax + LE target + index
// 1" and "lxvrhx + BE target + index 7" and "lxvrbx + BE target + index
// 15", but funciton IsValidSplatLoad() now will only return true when
// the data at index 0 is not nullptr. So we will not get into trouble for
// these cases.
//
// case 1 - lfiwzx/lfiwax
// 1.1: load result is i32 and is sign/zero extend to i64;
// 1.2: build a v2i64 vector type with above loaded value;
// 1.3: the vector has only one value at index 0, others are all undef;
// 1.4: on BE target, so that lfiwzx/lfiwax does not need any permute.
if (NumUsesOfInputLD == 1 &&
(Op->getValueType(0) == MVT::v2i64 && NewOpcode != PPCISD::LD_SPLAT &&
!Subtarget.isLittleEndian() && Subtarget.hasVSX() &&
Subtarget.hasLFIWAX()))
return SDValue();
// case 2 - lxvr[hb]x
// 2.1: load result is at most i16;
// 2.2: build a vector with above loaded value;
// 2.3: the vector has only one value at index 0, others are all undef;
// 2.4: on LE target, so that lxvr[hb]x does not need any permute.
if (NumUsesOfInputLD == 1 && Subtarget.isLittleEndian() &&
Subtarget.isISA3_1() && ElementSize <= 16)
return SDValue();
assert(NumUsesOfInputLD > 0 && "No uses of input LD of a build_vector?");
if (InputLoad->getNode()->hasNUsesOfValue(NumUsesOfInputLD, 0) &&
Subtarget.hasVSX()) {
SDValue Ops[] = {
LD->getChain(), // Chain
LD->getBasePtr(), // Ptr
DAG.getValueType(Op.getValueType()) // VT
};
SDValue LdSplt = DAG.getMemIntrinsicNode(
NewOpcode, dl, DAG.getVTList(Op.getValueType(), MVT::Other), Ops,
LD->getMemoryVT(), LD->getMemOperand());
// Replace all uses of the output chain of the original load with the
// output chain of the new load.
DAG.ReplaceAllUsesOfValueWith(InputLoad->getValue(1),
LdSplt.getValue(1));
return LdSplt;
}
}
// In 64BIT mode BUILD_VECTOR nodes that are not constant splats of up to
// 32-bits can be lowered to VSX instructions under certain conditions.
// Without VSX, there is no pattern more efficient than expanding the node.
if (Subtarget.hasVSX() && Subtarget.isPPC64() &&
haveEfficientBuildVectorPattern(BVN, Subtarget.hasDirectMove(),
Subtarget.hasP8Vector()))
return Op;
return SDValue();
}
uint64_t SplatBits = APSplatBits.getZExtValue();
uint64_t SplatUndef = APSplatUndef.getZExtValue();
unsigned SplatSize = SplatBitSize / 8;
// First, handle single instruction cases.
// All zeros?
if (SplatBits == 0) {
// Canonicalize all zero vectors to be v4i32.
if (Op.getValueType() != MVT::v4i32 || HasAnyUndefs) {
SDValue Z = DAG.getConstant(0, dl, MVT::v4i32);
Op = DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Z);
}
return Op;
}
// We have XXSPLTIW for constant splats four bytes wide.
// Given vector length is a multiple of 4, 2-byte splats can be replaced
// with 4-byte splats. We replicate the SplatBits in case of 2-byte splat to
// make a 4-byte splat element. For example: 2-byte splat of 0xABAB can be
// turned into a 4-byte splat of 0xABABABAB.
if (Subtarget.hasPrefixInstrs() && SplatSize == 2)
return getCanonicalConstSplat(SplatBits | (SplatBits << 16), SplatSize * 2,
Op.getValueType(), DAG, dl);
if (Subtarget.hasPrefixInstrs() && SplatSize == 4)
return getCanonicalConstSplat(SplatBits, SplatSize, Op.getValueType(), DAG,
dl);
// We have XXSPLTIB for constant splats one byte wide.
if (Subtarget.hasP9Vector() && SplatSize == 1)
return getCanonicalConstSplat(SplatBits, SplatSize, Op.getValueType(), DAG,
dl);
// If the sign extended value is in the range [-16,15], use VSPLTI[bhw].
int32_t SextVal= (int32_t(SplatBits << (32-SplatBitSize)) >>
(32-SplatBitSize));
if (SextVal >= -16 && SextVal <= 15)
return getCanonicalConstSplat(SextVal, SplatSize, Op.getValueType(), DAG,
dl);
// Two instruction sequences.
// If this value is in the range [-32,30] and is even, use:
// VSPLTI[bhw](val/2) + VSPLTI[bhw](val/2)
// If this value is in the range [17,31] and is odd, use:
// VSPLTI[bhw](val-16) - VSPLTI[bhw](-16)
// If this value is in the range [-31,-17] and is odd, use:
// VSPLTI[bhw](val+16) + VSPLTI[bhw](-16)
// Note the last two are three-instruction sequences.
if (SextVal >= -32 && SextVal <= 31) {
// To avoid having these optimizations undone by constant folding,
// we convert to a pseudo that will be expanded later into one of
// the above forms.
SDValue Elt = DAG.getConstant(SextVal, dl, MVT::i32);
EVT VT = (SplatSize == 1 ? MVT::v16i8 :
(SplatSize == 2 ? MVT::v8i16 : MVT::v4i32));
SDValue EltSize = DAG.getConstant(SplatSize, dl, MVT::i32);
SDValue RetVal = DAG.getNode(PPCISD::VADD_SPLAT, dl, VT, Elt, EltSize);
if (VT == Op.getValueType())
return RetVal;
else
return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), RetVal);
}
// If this is 0x8000_0000 x 4, turn into vspltisw + vslw. If it is
// 0x7FFF_FFFF x 4, turn it into not(0x8000_0000). This is important
// for fneg/fabs.
if (SplatSize == 4 && SplatBits == (0x7FFFFFFF&~SplatUndef)) {
// Make -1 and vspltisw -1:
SDValue OnesV = getCanonicalConstSplat(-1, 4, MVT::v4i32, DAG, dl);
// Make the VSLW intrinsic, computing 0x8000_0000.
SDValue Res = BuildIntrinsicOp(Intrinsic::ppc_altivec_vslw, OnesV,
OnesV, DAG, dl);
// xor by OnesV to invert it.
Res = DAG.getNode(ISD::XOR, dl, MVT::v4i32, Res, OnesV);
return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
}
// Check to see if this is a wide variety of vsplti*, binop self cases.
static const signed char SplatCsts[] = {
-1, 1, -2, 2, -3, 3, -4, 4, -5, 5, -6, 6, -7, 7,
-8, 8, -9, 9, -10, 10, -11, 11, -12, 12, -13, 13, 14, -14, 15, -15, -16
};
for (unsigned idx = 0; idx < array_lengthof(SplatCsts); ++idx) {
// Indirect through the SplatCsts array so that we favor 'vsplti -1' for
// cases which are ambiguous (e.g. formation of 0x8000_0000). 'vsplti -1'
int i = SplatCsts[idx];
// Figure out what shift amount will be used by altivec if shifted by i in
// this splat size.
unsigned TypeShiftAmt = i & (SplatBitSize-1);
// vsplti + shl self.
if (SextVal == (int)((unsigned)i << TypeShiftAmt)) {
SDValue Res = getCanonicalConstSplat(i, SplatSize, MVT::Other, DAG, dl);
static const unsigned IIDs[] = { // Intrinsic to use for each size.
Intrinsic::ppc_altivec_vslb, Intrinsic::ppc_altivec_vslh, 0,
Intrinsic::ppc_altivec_vslw
};
Res = BuildIntrinsicOp(IIDs[SplatSize-1], Res, Res, DAG, dl);
return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
}
// vsplti + srl self.
if (SextVal == (int)((unsigned)i >> TypeShiftAmt)) {
SDValue Res = getCanonicalConstSplat(i, SplatSize, MVT::Other, DAG, dl);
static const unsigned IIDs[] = { // Intrinsic to use for each size.
Intrinsic::ppc_altivec_vsrb, Intrinsic::ppc_altivec_vsrh, 0,
Intrinsic::ppc_altivec_vsrw
};
Res = BuildIntrinsicOp(IIDs[SplatSize-1], Res, Res, DAG, dl);
return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
}
// vsplti + rol self.
if (SextVal == (int)(((unsigned)i << TypeShiftAmt) |
((unsigned)i >> (SplatBitSize-TypeShiftAmt)))) {
SDValue Res = getCanonicalConstSplat(i, SplatSize, MVT::Other, DAG, dl);
static const unsigned IIDs[] = { // Intrinsic to use for each size.
Intrinsic::ppc_altivec_vrlb, Intrinsic::ppc_altivec_vrlh, 0,
Intrinsic::ppc_altivec_vrlw
};
Res = BuildIntrinsicOp(IIDs[SplatSize-1], Res, Res, DAG, dl);
return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
}
// t = vsplti c, result = vsldoi t, t, 1
if (SextVal == (int)(((unsigned)i << 8) | (i < 0 ? 0xFF : 0))) {
SDValue T = getCanonicalConstSplat(i, SplatSize, MVT::v16i8, DAG, dl);
unsigned Amt = Subtarget.isLittleEndian() ? 15 : 1;
return BuildVSLDOI(T, T, Amt, Op.getValueType(), DAG, dl);
}
// t = vsplti c, result = vsldoi t, t, 2
if (SextVal == (int)(((unsigned)i << 16) | (i < 0 ? 0xFFFF : 0))) {
SDValue T = getCanonicalConstSplat(i, SplatSize, MVT::v16i8, DAG, dl);
unsigned Amt = Subtarget.isLittleEndian() ? 14 : 2;
return BuildVSLDOI(T, T, Amt, Op.getValueType(), DAG, dl);
}
// t = vsplti c, result = vsldoi t, t, 3
if (SextVal == (int)(((unsigned)i << 24) | (i < 0 ? 0xFFFFFF : 0))) {
SDValue T = getCanonicalConstSplat(i, SplatSize, MVT::v16i8, DAG, dl);
unsigned Amt = Subtarget.isLittleEndian() ? 13 : 3;
return BuildVSLDOI(T, T, Amt, Op.getValueType(), DAG, dl);
}
}
return SDValue();
}
/// GeneratePerfectShuffle - Given an entry in the perfect-shuffle table, emit
/// the specified operations to build the shuffle.
static SDValue GeneratePerfectShuffle(unsigned PFEntry, SDValue LHS,
SDValue RHS, SelectionDAG &DAG,
const SDLoc &dl) {
unsigned OpNum = (PFEntry >> 26) & 0x0F;
unsigned LHSID = (PFEntry >> 13) & ((1 << 13)-1);
unsigned RHSID = (PFEntry >> 0) & ((1 << 13)-1);
enum {
OP_COPY = 0, // Copy, used for things like <u,u,u,3> to say it is <0,1,2,3>
OP_VMRGHW,
OP_VMRGLW,
OP_VSPLTISW0,
OP_VSPLTISW1,
OP_VSPLTISW2,
OP_VSPLTISW3,
OP_VSLDOI4,
OP_VSLDOI8,
OP_VSLDOI12
};
if (OpNum == OP_COPY) {
if (LHSID == (1*9+2)*9+3) return LHS;
assert(LHSID == ((4*9+5)*9+6)*9+7 && "Illegal OP_COPY!");
return RHS;
}
SDValue OpLHS, OpRHS;
OpLHS = GeneratePerfectShuffle(PerfectShuffleTable[LHSID], LHS, RHS, DAG, dl);
OpRHS = GeneratePerfectShuffle(PerfectShuffleTable[RHSID], LHS, RHS, DAG, dl);
int ShufIdxs[16];
switch (OpNum) {
default: llvm_unreachable("Unknown i32 permute!");
case OP_VMRGHW:
ShufIdxs[ 0] = 0; ShufIdxs[ 1] = 1; ShufIdxs[ 2] = 2; ShufIdxs[ 3] = 3;
ShufIdxs[ 4] = 16; ShufIdxs[ 5] = 17; ShufIdxs[ 6] = 18; ShufIdxs[ 7] = 19;
ShufIdxs[ 8] = 4; ShufIdxs[ 9] = 5; ShufIdxs[10] = 6; ShufIdxs[11] = 7;
ShufIdxs[12] = 20; ShufIdxs[13] = 21; ShufIdxs[14] = 22; ShufIdxs[15] = 23;
break;
case OP_VMRGLW:
ShufIdxs[ 0] = 8; ShufIdxs[ 1] = 9; ShufIdxs[ 2] = 10; ShufIdxs[ 3] = 11;
ShufIdxs[ 4] = 24; ShufIdxs[ 5] = 25; ShufIdxs[ 6] = 26; ShufIdxs[ 7] = 27;
ShufIdxs[ 8] = 12; ShufIdxs[ 9] = 13; ShufIdxs[10] = 14; ShufIdxs[11] = 15;
ShufIdxs[12] = 28; ShufIdxs[13] = 29; ShufIdxs[14] = 30; ShufIdxs[15] = 31;
break;
case OP_VSPLTISW0:
for (unsigned i = 0; i != 16; ++i)
ShufIdxs[i] = (i&3)+0;
break;
case OP_VSPLTISW1:
for (unsigned i = 0; i != 16; ++i)
ShufIdxs[i] = (i&3)+4;
break;
case OP_VSPLTISW2:
for (unsigned i = 0; i != 16; ++i)
ShufIdxs[i] = (i&3)+8;
break;
case OP_VSPLTISW3:
for (unsigned i = 0; i != 16; ++i)
ShufIdxs[i] = (i&3)+12;
break;
case OP_VSLDOI4:
return BuildVSLDOI(OpLHS, OpRHS, 4, OpLHS.getValueType(), DAG, dl);
case OP_VSLDOI8:
return BuildVSLDOI(OpLHS, OpRHS, 8, OpLHS.getValueType(), DAG, dl);
case OP_VSLDOI12:
return BuildVSLDOI(OpLHS, OpRHS, 12, OpLHS.getValueType(), DAG, dl);
}
EVT VT = OpLHS.getValueType();
OpLHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, OpLHS);
OpRHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, OpRHS);
SDValue T = DAG.getVectorShuffle(MVT::v16i8, dl, OpLHS, OpRHS, ShufIdxs);
return DAG.getNode(ISD::BITCAST, dl, VT, T);
}
/// lowerToVINSERTB - Return the SDValue if this VECTOR_SHUFFLE can be handled
/// by the VINSERTB instruction introduced in ISA 3.0, else just return default
/// SDValue.
SDValue PPCTargetLowering::lowerToVINSERTB(ShuffleVectorSDNode *N,
SelectionDAG &DAG) const {
const unsigned BytesInVector = 16;
bool IsLE = Subtarget.isLittleEndian();
SDLoc dl(N);
SDValue V1 = N->getOperand(0);
SDValue V2 = N->getOperand(1);
unsigned ShiftElts = 0, InsertAtByte = 0;
bool Swap = false;
// Shifts required to get the byte we want at element 7.
unsigned LittleEndianShifts[] = {8, 7, 6, 5, 4, 3, 2, 1,
0, 15, 14, 13, 12, 11, 10, 9};
unsigned BigEndianShifts[] = {9, 10, 11, 12, 13, 14, 15, 0,
1, 2, 3, 4, 5, 6, 7, 8};
ArrayRef<int> Mask = N->getMask();
int OriginalOrder[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
// For each mask element, find out if we're just inserting something
// from V2 into V1 or vice versa.
// Possible permutations inserting an element from V2 into V1:
// X, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
// 0, X, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
// ...
// 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, X
// Inserting from V1 into V2 will be similar, except mask range will be
// [16,31].
bool FoundCandidate = false;
// If both vector operands for the shuffle are the same vector, the mask
// will contain only elements from the first one and the second one will be
// undef.
unsigned VINSERTBSrcElem = IsLE ? 8 : 7;
// Go through the mask of half-words to find an element that's being moved
// from one vector to the other.
for (unsigned i = 0; i < BytesInVector; ++i) {
unsigned CurrentElement = Mask[i];
// If 2nd operand is undefined, we should only look for element 7 in the
// Mask.
if (V2.isUndef() && CurrentElement != VINSERTBSrcElem)
continue;
bool OtherElementsInOrder = true;
// Examine the other elements in the Mask to see if they're in original
// order.
for (unsigned j = 0; j < BytesInVector; ++j) {
if (j == i)
continue;
// If CurrentElement is from V1 [0,15], then we the rest of the Mask to be
// from V2 [16,31] and vice versa. Unless the 2nd operand is undefined,
// in which we always assume we're always picking from the 1st operand.
int MaskOffset =
(!V2.isUndef() && CurrentElement < BytesInVector) ? BytesInVector : 0;
if (Mask[j] != OriginalOrder[j] + MaskOffset) {
OtherElementsInOrder = false;
break;
}
}
// If other elements are in original order, we record the number of shifts
// we need to get the element we want into element 7. Also record which byte
// in the vector we should insert into.
if (OtherElementsInOrder) {
// If 2nd operand is undefined, we assume no shifts and no swapping.
if (V2.isUndef()) {
ShiftElts = 0;
Swap = false;
} else {
// Only need the last 4-bits for shifts because operands will be swapped if CurrentElement is >= 2^4.
ShiftElts = IsLE ? LittleEndianShifts[CurrentElement & 0xF]
: BigEndianShifts[CurrentElement & 0xF];
Swap = CurrentElement < BytesInVector;
}
InsertAtByte = IsLE ? BytesInVector - (i + 1) : i;
FoundCandidate = true;
break;
}
}
if (!FoundCandidate)
return SDValue();
// Candidate found, construct the proper SDAG sequence with VINSERTB,
// optionally with VECSHL if shift is required.
if (Swap)
std::swap(V1, V2);
if (V2.isUndef())
V2 = V1;
if (ShiftElts) {
SDValue Shl = DAG.getNode(PPCISD::VECSHL, dl, MVT::v16i8, V2, V2,
DAG.getConstant(ShiftElts, dl, MVT::i32));
return DAG.getNode(PPCISD::VECINSERT, dl, MVT::v16i8, V1, Shl,
DAG.getConstant(InsertAtByte, dl, MVT::i32));
}
return DAG.getNode(PPCISD::VECINSERT, dl, MVT::v16i8, V1, V2,
DAG.getConstant(InsertAtByte, dl, MVT::i32));
}
/// lowerToVINSERTH - Return the SDValue if this VECTOR_SHUFFLE can be handled
/// by the VINSERTH instruction introduced in ISA 3.0, else just return default
/// SDValue.
SDValue PPCTargetLowering::lowerToVINSERTH(ShuffleVectorSDNode *N,
SelectionDAG &DAG) const {
const unsigned NumHalfWords = 8;
const unsigned BytesInVector = NumHalfWords * 2;
// Check that the shuffle is on half-words.
if (!isNByteElemShuffleMask(N, 2, 1))
return SDValue();
bool IsLE = Subtarget.isLittleEndian();
SDLoc dl(N);
SDValue V1 = N->getOperand(0);
SDValue V2 = N->getOperand(1);
unsigned ShiftElts = 0, InsertAtByte = 0;
bool Swap = false;
// Shifts required to get the half-word we want at element 3.
unsigned LittleEndianShifts[] = {4, 3, 2, 1, 0, 7, 6, 5};
unsigned BigEndianShifts[] = {5, 6, 7, 0, 1, 2, 3, 4};
uint32_t Mask = 0;
uint32_t OriginalOrderLow = 0x1234567;
uint32_t OriginalOrderHigh = 0x89ABCDEF;
// Now we look at mask elements 0,2,4,6,8,10,12,14. Pack the mask into a
// 32-bit space, only need 4-bit nibbles per element.
for (unsigned i = 0; i < NumHalfWords; ++i) {
unsigned MaskShift = (NumHalfWords - 1 - i) * 4;
Mask |= ((uint32_t)(N->getMaskElt(i * 2) / 2) << MaskShift);
}
// For each mask element, find out if we're just inserting something
// from V2 into V1 or vice versa. Possible permutations inserting an element
// from V2 into V1:
// X, 1, 2, 3, 4, 5, 6, 7
// 0, X, 2, 3, 4, 5, 6, 7
// 0, 1, X, 3, 4, 5, 6, 7
// 0, 1, 2, X, 4, 5, 6, 7
// 0, 1, 2, 3, X, 5, 6, 7
// 0, 1, 2, 3, 4, X, 6, 7
// 0, 1, 2, 3, 4, 5, X, 7
// 0, 1, 2, 3, 4, 5, 6, X
// Inserting from V1 into V2 will be similar, except mask range will be [8,15].
bool FoundCandidate = false;
// Go through the mask of half-words to find an element that's being moved
// from one vector to the other.
for (unsigned i = 0; i < NumHalfWords; ++i) {
unsigned MaskShift = (NumHalfWords - 1 - i) * 4;
uint32_t MaskOneElt = (Mask >> MaskShift) & 0xF;
uint32_t MaskOtherElts = ~(0xF << MaskShift);
uint32_t TargetOrder = 0x0;
// If both vector operands for the shuffle are the same vector, the mask
// will contain only elements from the first one and the second one will be
// undef.
if (V2.isUndef()) {
ShiftElts = 0;
unsigned VINSERTHSrcElem = IsLE ? 4 : 3;
TargetOrder = OriginalOrderLow;
Swap = false;
// Skip if not the correct element or mask of other elements don't equal
// to our expected order.
if (MaskOneElt == VINSERTHSrcElem &&
(Mask & MaskOtherElts) == (TargetOrder & MaskOtherElts)) {
InsertAtByte = IsLE ? BytesInVector - (i + 1) * 2 : i * 2;
FoundCandidate = true;
break;
}
} else { // If both operands are defined.
// Target order is [8,15] if the current mask is between [0,7].
TargetOrder =
(MaskOneElt < NumHalfWords) ? OriginalOrderHigh : OriginalOrderLow;
// Skip if mask of other elements don't equal our expected order.
if ((Mask & MaskOtherElts) == (TargetOrder & MaskOtherElts)) {
// We only need the last 3 bits for the number of shifts.
ShiftElts = IsLE ? LittleEndianShifts[MaskOneElt & 0x7]
: BigEndianShifts[MaskOneElt & 0x7];
InsertAtByte = IsLE ? BytesInVector - (i + 1) * 2 : i * 2;
Swap = MaskOneElt < NumHalfWords;
FoundCandidate = true;
break;
}
}
}
if (!FoundCandidate)
return SDValue();
// Candidate found, construct the proper SDAG sequence with VINSERTH,
// optionally with VECSHL if shift is required.
if (Swap)
std::swap(V1, V2);
if (V2.isUndef())
V2 = V1;
SDValue Conv1 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
if (ShiftElts) {
// Double ShiftElts because we're left shifting on v16i8 type.
SDValue Shl = DAG.getNode(PPCISD::VECSHL, dl, MVT::v16i8, V2, V2,
DAG.getConstant(2 * ShiftElts, dl, MVT::i32));
SDValue Conv2 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, Shl);
SDValue Ins = DAG.getNode(PPCISD::VECINSERT, dl, MVT::v8i16, Conv1, Conv2,
DAG.getConstant(InsertAtByte, dl, MVT::i32));
return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, Ins);
}
SDValue Conv2 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V2);
SDValue Ins = DAG.getNode(PPCISD::VECINSERT, dl, MVT::v8i16, Conv1, Conv2,
DAG.getConstant(InsertAtByte, dl, MVT::i32));
return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, Ins);
}
/// lowerToXXSPLTI32DX - Return the SDValue if this VECTOR_SHUFFLE can be
/// handled by the XXSPLTI32DX instruction introduced in ISA 3.1, otherwise
/// return the default SDValue.
SDValue PPCTargetLowering::lowerToXXSPLTI32DX(ShuffleVectorSDNode *SVN,
SelectionDAG &DAG) const {
// The LHS and RHS may be bitcasts to v16i8 as we canonicalize shuffles
// to v16i8. Peek through the bitcasts to get the actual operands.
SDValue LHS = peekThroughBitcasts(SVN->getOperand(0));
SDValue RHS = peekThroughBitcasts(SVN->getOperand(1));
auto ShuffleMask = SVN->getMask();
SDValue VecShuffle(SVN, 0);
SDLoc DL(SVN);
// Check that we have a four byte shuffle.
if (!isNByteElemShuffleMask(SVN, 4, 1))
return SDValue();
// Canonicalize the RHS being a BUILD_VECTOR when lowering to xxsplti32dx.
if (RHS->getOpcode() != ISD::BUILD_VECTOR) {
std::swap(LHS, RHS);
VecShuffle = DAG.getCommutedVectorShuffle(*SVN);
ShuffleMask = cast<ShuffleVectorSDNode>(VecShuffle)->getMask();
}
// Ensure that the RHS is a vector of constants.
BuildVectorSDNode *BVN = dyn_cast<BuildVectorSDNode>(RHS.getNode());
if (!BVN)
return SDValue();
// Check if RHS is a splat of 4-bytes (or smaller).
APInt APSplatValue, APSplatUndef;
unsigned SplatBitSize;
bool HasAnyUndefs;
if (!BVN->isConstantSplat(APSplatValue, APSplatUndef, SplatBitSize,
HasAnyUndefs, 0, !Subtarget.isLittleEndian()) ||
SplatBitSize > 32)
return SDValue();
// Check that the shuffle mask matches the semantics of XXSPLTI32DX.
// The instruction splats a constant C into two words of the source vector
// producing { C, Unchanged, C, Unchanged } or { Unchanged, C, Unchanged, C }.
// Thus we check that the shuffle mask is the equivalent of
// <0, [4-7], 2, [4-7]> or <[4-7], 1, [4-7], 3> respectively.
// Note: the check above of isNByteElemShuffleMask() ensures that the bytes
// within each word are consecutive, so we only need to check the first byte.
SDValue Index;
bool IsLE = Subtarget.isLittleEndian();
if ((ShuffleMask[0] == 0 && ShuffleMask[8] == 8) &&
(ShuffleMask[4] % 4 == 0 && ShuffleMask[12] % 4 == 0 &&
ShuffleMask[4] > 15 && ShuffleMask[12] > 15))
Index = DAG.getTargetConstant(IsLE ? 0 : 1, DL, MVT::i32);
else if ((ShuffleMask[4] == 4 && ShuffleMask[12] == 12) &&
(ShuffleMask[0] % 4 == 0 && ShuffleMask[8] % 4 == 0 &&
ShuffleMask[0] > 15 && ShuffleMask[8] > 15))
Index = DAG.getTargetConstant(IsLE ? 1 : 0, DL, MVT::i32);
else
return SDValue();
// If the splat is narrower than 32-bits, we need to get the 32-bit value
// for XXSPLTI32DX.
unsigned SplatVal = APSplatValue.getZExtValue();
for (; SplatBitSize < 32; SplatBitSize <<= 1)
SplatVal |= (SplatVal << SplatBitSize);
SDValue SplatNode = DAG.getNode(
PPCISD::XXSPLTI32DX, DL, MVT::v2i64, DAG.getBitcast(MVT::v2i64, LHS),
Index, DAG.getTargetConstant(SplatVal, DL, MVT::i32));
return DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, SplatNode);
}
/// LowerROTL - Custom lowering for ROTL(v1i128) to vector_shuffle(v16i8).
/// We lower ROTL(v1i128) to vector_shuffle(v16i8) only if shift amount is
/// a multiple of 8. Otherwise convert it to a scalar rotation(i128)
/// i.e (or (shl x, C1), (srl x, 128-C1)).
SDValue PPCTargetLowering::LowerROTL(SDValue Op, SelectionDAG &DAG) const {
assert(Op.getOpcode() == ISD::ROTL && "Should only be called for ISD::ROTL");
assert(Op.getValueType() == MVT::v1i128 &&
"Only set v1i128 as custom, other type shouldn't reach here!");
SDLoc dl(Op);
SDValue N0 = peekThroughBitcasts(Op.getOperand(0));
SDValue N1 = peekThroughBitcasts(Op.getOperand(1));
unsigned SHLAmt = N1.getConstantOperandVal(0);
if (SHLAmt % 8 == 0) {
SmallVector<int, 16> Mask(16, 0);
std::iota(Mask.begin(), Mask.end(), 0);
std::rotate(Mask.begin(), Mask.begin() + SHLAmt / 8, Mask.end());
if (SDValue Shuffle =
DAG.getVectorShuffle(MVT::v16i8, dl, DAG.getBitcast(MVT::v16i8, N0),
DAG.getUNDEF(MVT::v16i8), Mask))
return DAG.getNode(ISD::BITCAST, dl, MVT::v1i128, Shuffle);
}
SDValue ArgVal = DAG.getBitcast(MVT::i128, N0);
SDValue SHLOp = DAG.getNode(ISD::SHL, dl, MVT::i128, ArgVal,
DAG.getConstant(SHLAmt, dl, MVT::i32));
SDValue SRLOp = DAG.getNode(ISD::SRL, dl, MVT::i128, ArgVal,
DAG.getConstant(128 - SHLAmt, dl, MVT::i32));
SDValue OROp = DAG.getNode(ISD::OR, dl, MVT::i128, SHLOp, SRLOp);
return DAG.getNode(ISD::BITCAST, dl, MVT::v1i128, OROp);
}
/// LowerVECTOR_SHUFFLE - Return the code we lower for VECTOR_SHUFFLE. If this
/// is a shuffle we can handle in a single instruction, return it. Otherwise,
/// return the code it can be lowered into. Worst case, it can always be
/// lowered into a vperm.
SDValue PPCTargetLowering::LowerVECTOR_SHUFFLE(SDValue Op,
SelectionDAG &DAG) const {
SDLoc dl(Op);
SDValue V1 = Op.getOperand(0);
SDValue V2 = Op.getOperand(1);
ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
// Any nodes that were combined in the target-independent combiner prior
// to vector legalization will not be sent to the target combine. Try to
// combine it here.
if (SDValue NewShuffle = combineVectorShuffle(SVOp, DAG)) {
if (!isa<ShuffleVectorSDNode>(NewShuffle))
return NewShuffle;
Op = NewShuffle;
SVOp = cast<ShuffleVectorSDNode>(Op);
V1 = Op.getOperand(0);
V2 = Op.getOperand(1);
}
EVT VT = Op.getValueType();
bool isLittleEndian = Subtarget.isLittleEndian();
unsigned ShiftElts, InsertAtByte;
bool Swap = false;
// If this is a load-and-splat, we can do that with a single instruction
// in some cases. However if the load has multiple uses, we don't want to
// combine it because that will just produce multiple loads.
bool IsPermutedLoad = false;
const SDValue *InputLoad = getNormalLoadInput(V1, IsPermutedLoad);
if (InputLoad && Subtarget.hasVSX() && V2.isUndef() &&
(PPC::isSplatShuffleMask(SVOp, 4) || PPC::isSplatShuffleMask(SVOp, 8)) &&
InputLoad->hasOneUse()) {
bool IsFourByte = PPC::isSplatShuffleMask(SVOp, 4);
int SplatIdx =
PPC::getSplatIdxForPPCMnemonics(SVOp, IsFourByte ? 4 : 8, DAG);
// The splat index for permuted loads will be in the left half of the vector
// which is strictly wider than the loaded value by 8 bytes. So we need to
// adjust the splat index to point to the correct address in memory.
if (IsPermutedLoad) {
assert((isLittleEndian || IsFourByte) &&
"Unexpected size for permuted load on big endian target");
SplatIdx += IsFourByte ? 2 : 1;
assert((SplatIdx < (IsFourByte ? 4 : 2)) &&
"Splat of a value outside of the loaded memory");
}
LoadSDNode *LD = cast<LoadSDNode>(*InputLoad);
// For 4-byte load-and-splat, we need Power9.
if ((IsFourByte && Subtarget.hasP9Vector()) || !IsFourByte) {
uint64_t Offset = 0;
if (IsFourByte)
Offset = isLittleEndian ? (3 - SplatIdx) * 4 : SplatIdx * 4;
else
Offset = isLittleEndian ? (1 - SplatIdx) * 8 : SplatIdx * 8;
// If the width of the load is the same as the width of the splat,
// loading with an offset would load the wrong memory.
if (LD->getValueType(0).getSizeInBits() == (IsFourByte ? 32 : 64))
Offset = 0;
SDValue BasePtr = LD->getBasePtr();
if (Offset != 0)
BasePtr = DAG.getNode(ISD::ADD, dl, getPointerTy(DAG.getDataLayout()),
BasePtr, DAG.getIntPtrConstant(Offset, dl));
SDValue Ops[] = {
LD->getChain(), // Chain
BasePtr, // BasePtr
DAG.getValueType(Op.getValueType()) // VT
};
SDVTList VTL =
DAG.getVTList(IsFourByte ? MVT::v4i32 : MVT::v2i64, MVT::Other);
SDValue LdSplt =
DAG.getMemIntrinsicNode(PPCISD::LD_SPLAT, dl, VTL,
Ops, LD->getMemoryVT(), LD->getMemOperand());
DAG.ReplaceAllUsesOfValueWith(InputLoad->getValue(1), LdSplt.getValue(1));
if (LdSplt.getValueType() != SVOp->getValueType(0))
LdSplt = DAG.getBitcast(SVOp->getValueType(0), LdSplt);
return LdSplt;
}
}
if (Subtarget.hasP9Vector() &&
PPC::isXXINSERTWMask(SVOp, ShiftElts, InsertAtByte, Swap,
isLittleEndian)) {
if (Swap)
std::swap(V1, V2);
SDValue Conv1 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, V1);
SDValue Conv2 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, V2);
if (ShiftElts) {
SDValue Shl = DAG.getNode(PPCISD::VECSHL, dl, MVT::v4i32, Conv2, Conv2,
DAG.getConstant(ShiftElts, dl, MVT::i32));
SDValue Ins = DAG.getNode(PPCISD::VECINSERT, dl, MVT::v4i32, Conv1, Shl,
DAG.getConstant(InsertAtByte, dl, MVT::i32));
return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, Ins);
}
SDValue Ins = DAG.getNode(PPCISD::VECINSERT, dl, MVT::v4i32, Conv1, Conv2,
DAG.getConstant(InsertAtByte, dl, MVT::i32));
return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, Ins);
}
if (Subtarget.hasPrefixInstrs()) {
SDValue SplatInsertNode;
if ((SplatInsertNode = lowerToXXSPLTI32DX(SVOp, DAG)))
return SplatInsertNode;
}
if (Subtarget.hasP9Altivec()) {
SDValue NewISDNode;
if ((NewISDNode = lowerToVINSERTH(SVOp, DAG)))
return NewISDNode;
if ((NewISDNode = lowerToVINSERTB(SVOp, DAG)))
return NewISDNode;
}
if (Subtarget.hasVSX() &&
PPC::isXXSLDWIShuffleMask(SVOp, ShiftElts, Swap, isLittleEndian)) {
if (Swap)
std::swap(V1, V2);
SDValue Conv1 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, V1);
SDValue Conv2 =
DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, V2.isUndef() ? V1 : V2);
SDValue Shl = DAG.getNode(PPCISD::VECSHL, dl, MVT::v4i32, Conv1, Conv2,
DAG.getConstant(ShiftElts, dl, MVT::i32));
return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, Shl);
}
if (Subtarget.hasVSX() &&
PPC::isXXPERMDIShuffleMask(SVOp, ShiftElts, Swap, isLittleEndian)) {
if (Swap)
std::swap(V1, V2);
SDValue Conv1 = DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V1);
SDValue Conv2 =
DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V2.isUndef() ? V1 : V2);
SDValue PermDI = DAG.getNode(PPCISD::XXPERMDI, dl, MVT::v2i64, Conv1, Conv2,
DAG.getConstant(ShiftElts, dl, MVT::i32));
return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, PermDI);
}
if (Subtarget.hasP9Vector()) {
if (PPC::isXXBRHShuffleMask(SVOp)) {
SDValue Conv = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
SDValue ReveHWord = DAG.getNode(ISD::BSWAP, dl, MVT::v8i16, Conv);
return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, ReveHWord);
} else if (PPC::isXXBRWShuffleMask(SVOp)) {
SDValue Conv = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, V1);
SDValue ReveWord = DAG.getNode(ISD::BSWAP, dl, MVT::v4i32, Conv);
return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, ReveWord);
} else if (PPC::isXXBRDShuffleMask(SVOp)) {
SDValue Conv = DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V1);
SDValue ReveDWord = DAG.getNode(ISD::BSWAP, dl, MVT::v2i64, Conv);
return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, ReveDWord);
} else if (PPC::isXXBRQShuffleMask(SVOp)) {
SDValue Conv = DAG.getNode(ISD::BITCAST, dl, MVT::v1i128, V1);
SDValue ReveQWord = DAG.getNode(ISD::BSWAP, dl, MVT::v1i128, Conv);
return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, ReveQWord);
}
}
if (Subtarget.hasVSX()) {
if (V2.isUndef() && PPC::isSplatShuffleMask(SVOp, 4)) {
int SplatIdx = PPC::getSplatIdxForPPCMnemonics(SVOp, 4, DAG);
SDValue Conv = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, V1);
SDValue Splat = DAG.getNode(PPCISD::XXSPLT, dl, MVT::v4i32, Conv,
DAG.getConstant(SplatIdx, dl, MVT::i32));
return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, Splat);
}
// Left shifts of 8 bytes are actually swaps. Convert accordingly.
if (V2.isUndef() && PPC::isVSLDOIShuffleMask(SVOp, 1, DAG) == 8) {
SDValue Conv = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, V1);
SDValue Swap = DAG.getNode(PPCISD::SWAP_NO_CHAIN, dl, MVT::v2f64, Conv);
return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, Swap);
}
}
// Cases that are handled by instructions that take permute immediates
// (such as vsplt*) should be left as VECTOR_SHUFFLE nodes so they can be
// selected by the instruction selector.
if (V2.isUndef()) {
if (PPC::isSplatShuffleMask(SVOp, 1) ||
PPC::isSplatShuffleMask(SVOp, 2) ||
PPC::isSplatShuffleMask(SVOp, 4) ||
PPC::isVPKUWUMShuffleMask(SVOp, 1, DAG) ||
PPC::isVPKUHUMShuffleMask(SVOp, 1, DAG) ||
PPC::isVSLDOIShuffleMask(SVOp, 1, DAG) != -1 ||
PPC::isVMRGLShuffleMask(SVOp, 1, 1, DAG) ||
PPC::isVMRGLShuffleMask(SVOp, 2, 1, DAG) ||
PPC::isVMRGLShuffleMask(SVOp, 4, 1, DAG) ||
PPC::isVMRGHShuffleMask(SVOp, 1, 1, DAG) ||
PPC::isVMRGHShuffleMask(SVOp, 2, 1, DAG) ||
PPC::isVMRGHShuffleMask(SVOp, 4, 1, DAG) ||
(Subtarget.hasP8Altivec() && (
PPC::isVPKUDUMShuffleMask(SVOp, 1, DAG) ||
PPC::isVMRGEOShuffleMask(SVOp, true, 1, DAG) ||
PPC::isVMRGEOShuffleMask(SVOp, false, 1, DAG)))) {
return Op;
}
}
// Altivec has a variety of "shuffle immediates" that take two vector inputs
// and produce a fixed permutation. If any of these match, do not lower to
// VPERM.
unsigned int ShuffleKind = isLittleEndian ? 2 : 0;
if (PPC::isVPKUWUMShuffleMask(SVOp, ShuffleKind, DAG) ||
PPC::isVPKUHUMShuffleMask(SVOp, ShuffleKind, DAG) ||
PPC::isVSLDOIShuffleMask(SVOp, ShuffleKind, DAG) != -1 ||
PPC::isVMRGLShuffleMask(SVOp, 1, ShuffleKind, DAG) ||
PPC::isVMRGLShuffleMask(SVOp, 2, ShuffleKind, DAG) ||
PPC::isVMRGLShuffleMask(SVOp, 4, ShuffleKind, DAG) ||
PPC::isVMRGHShuffleMask(SVOp, 1, ShuffleKind, DAG) ||
PPC::isVMRGHShuffleMask(SVOp, 2, ShuffleKind, DAG) ||
PPC::isVMRGHShuffleMask(SVOp, 4, ShuffleKind, DAG) ||
(Subtarget.hasP8Altivec() && (
PPC::isVPKUDUMShuffleMask(SVOp, ShuffleKind, DAG) ||
PPC::isVMRGEOShuffleMask(SVOp, true, ShuffleKind, DAG) ||
PPC::isVMRGEOShuffleMask(SVOp, false, ShuffleKind, DAG))))
return Op;
// Check to see if this is a shuffle of 4-byte values. If so, we can use our
// perfect shuffle table to emit an optimal matching sequence.
ArrayRef<int> PermMask = SVOp->getMask();
unsigned PFIndexes[4];
bool isFourElementShuffle = true;
for (unsigned i = 0; i != 4 && isFourElementShuffle; ++i) { // Element number
unsigned EltNo = 8; // Start out undef.
for (unsigned j = 0; j != 4; ++j) { // Intra-element byte.
if (PermMask[i*4+j] < 0)
continue; // Undef, ignore it.
unsigned ByteSource = PermMask[i*4+j];
if ((ByteSource & 3) != j) {
isFourElementShuffle = false;
break;
}
if (EltNo == 8) {
EltNo = ByteSource/4;
} else if (EltNo != ByteSource/4) {
isFourElementShuffle = false;
break;
}
}
PFIndexes[i] = EltNo;
}
// If this shuffle can be expressed as a shuffle of 4-byte elements, use the
// perfect shuffle vector to determine if it is cost effective to do this as
// discrete instructions, or whether we should use a vperm.
// For now, we skip this for little endian until such time as we have a
// little-endian perfect shuffle table.
if (isFourElementShuffle && !isLittleEndian) {
// Compute the index in the perfect shuffle table.
unsigned PFTableIndex =
PFIndexes[0]*9*9*9+PFIndexes[1]*9*9+PFIndexes[2]*9+PFIndexes[3];
unsigned PFEntry = PerfectShuffleTable[PFTableIndex];
unsigned Cost = (PFEntry >> 30);
// Determining when to avoid vperm is tricky. Many things affect the cost
// of vperm, particularly how many times the perm mask needs to be computed.
// For example, if the perm mask can be hoisted out of a loop or is already
// used (perhaps because there are multiple permutes with the same shuffle
// mask?) the vperm has a cost of 1. OTOH, hoisting the permute mask out of
// the loop requires an extra register.
//
// As a compromise, we only emit discrete instructions if the shuffle can be
// generated in 3 or fewer operations. When we have loop information
// available, if this block is within a loop, we should avoid using vperm
// for 3-operation perms and use a constant pool load instead.
if (Cost < 3)
return GeneratePerfectShuffle(PFEntry, V1, V2, DAG, dl);
}
// Lower this to a VPERM(V1, V2, V3) expression, where V3 is a constant
// vector that will get spilled to the constant pool.
if (V2.isUndef()) V2 = V1;
// The SHUFFLE_VECTOR mask is almost exactly what we want for vperm, except
// that it is in input element units, not in bytes. Convert now.
// For little endian, the order of the input vectors is reversed, and
// the permutation mask is complemented with respect to 31. This is
// necessary to produce proper semantics with the big-endian-biased vperm
// instruction.
EVT EltVT = V1.getValueType().getVectorElementType();
unsigned BytesPerElement = EltVT.getSizeInBits()/8;
SmallVector<SDValue, 16> ResultMask;
for (unsigned i = 0, e = VT.getVectorNumElements(); i != e; ++i) {
unsigned SrcElt = PermMask[i] < 0 ? 0 : PermMask[i];
for (unsigned j = 0; j != BytesPerElement; ++j)
if (isLittleEndian)
ResultMask.push_back(DAG.getConstant(31 - (SrcElt*BytesPerElement + j),
dl, MVT::i32));
else
ResultMask.push_back(DAG.getConstant(SrcElt*BytesPerElement + j, dl,
MVT::i32));
}
ShufflesHandledWithVPERM++;
SDValue VPermMask = DAG.getBuildVector(MVT::v16i8, dl, ResultMask);
LLVM_DEBUG(dbgs() << "Emitting a VPERM for the following shuffle:\n");
LLVM_DEBUG(SVOp->dump());
LLVM_DEBUG(dbgs() << "With the following permute control vector:\n");
LLVM_DEBUG(VPermMask.dump());
if (isLittleEndian)
return DAG.getNode(PPCISD::VPERM, dl, V1.getValueType(),
V2, V1, VPermMask);
else
return DAG.getNode(PPCISD::VPERM, dl, V1.getValueType(),
V1, V2, VPermMask);
}
/// getVectorCompareInfo - Given an intrinsic, return false if it is not a
/// vector comparison. If it is, return true and fill in Opc/isDot with
/// information about the intrinsic.
static bool getVectorCompareInfo(SDValue Intrin, int &CompareOpc,
bool &isDot, const PPCSubtarget &Subtarget) {
unsigned IntrinsicID =
cast<ConstantSDNode>(Intrin.getOperand(0))->getZExtValue();
CompareOpc = -1;
isDot = false;
switch (IntrinsicID) {
default:
return false;
// Comparison predicates.
case Intrinsic::ppc_altivec_vcmpbfp_p:
CompareOpc = 966;
isDot = true;
break;
case Intrinsic::ppc_altivec_vcmpeqfp_p:
CompareOpc = 198;
isDot = true;
break;
case Intrinsic::ppc_altivec_vcmpequb_p:
CompareOpc = 6;
isDot = true;
break;
case Intrinsic::ppc_altivec_vcmpequh_p:
CompareOpc = 70;
isDot = true;
break;
case Intrinsic::ppc_altivec_vcmpequw_p:
CompareOpc = 134;
isDot = true;
break;
case Intrinsic::ppc_altivec_vcmpequd_p:
if (Subtarget.hasVSX() || Subtarget.hasP8Altivec()) {
CompareOpc = 199;
isDot = true;
} else
return false;
break;
case Intrinsic::ppc_altivec_vcmpneb_p:
case Intrinsic::ppc_altivec_vcmpneh_p:
case Intrinsic::ppc_altivec_vcmpnew_p:
case Intrinsic::ppc_altivec_vcmpnezb_p:
case Intrinsic::ppc_altivec_vcmpnezh_p:
case Intrinsic::ppc_altivec_vcmpnezw_p:
if (Subtarget.hasP9Altivec()) {
switch (IntrinsicID) {
default:
llvm_unreachable("Unknown comparison intrinsic.");
case Intrinsic::ppc_altivec_vcmpneb_p:
CompareOpc = 7;
break;
case Intrinsic::ppc_altivec_vcmpneh_p:
CompareOpc = 71;
break;
case Intrinsic::ppc_altivec_vcmpnew_p:
CompareOpc = 135;
break;
case Intrinsic::ppc_altivec_vcmpnezb_p:
CompareOpc = 263;
break;
case Intrinsic::ppc_altivec_vcmpnezh_p:
CompareOpc = 327;
break;
case Intrinsic::ppc_altivec_vcmpnezw_p:
CompareOpc = 391;
break;
}
isDot = true;
} else
return false;
break;
case Intrinsic::ppc_altivec_vcmpgefp_p:
CompareOpc = 454;
isDot = true;
break;
case Intrinsic::ppc_altivec_vcmpgtfp_p:
CompareOpc = 710;
isDot = true;
break;
case Intrinsic::ppc_altivec_vcmpgtsb_p:
CompareOpc = 774;
isDot = true;
break;
case Intrinsic::ppc_altivec_vcmpgtsh_p:
CompareOpc = 838;
isDot = true;
break;
case Intrinsic::ppc_altivec_vcmpgtsw_p:
CompareOpc = 902;
isDot = true;
break;
case Intrinsic::ppc_altivec_vcmpgtsd_p:
if (Subtarget.hasVSX() || Subtarget.hasP8Altivec()) {
CompareOpc = 967;
isDot = true;
} else
return false;
break;
case Intrinsic::ppc_altivec_vcmpgtub_p:
CompareOpc = 518;
isDot = true;
break;
case Intrinsic::ppc_altivec_vcmpgtuh_p:
CompareOpc = 582;
isDot = true;
break;
case Intrinsic::ppc_altivec_vcmpgtuw_p:
CompareOpc = 646;
isDot = true;
break;
case Intrinsic::ppc_altivec_vcmpgtud_p:
if (Subtarget.hasVSX() || Subtarget.hasP8Altivec()) {
CompareOpc = 711;
isDot = true;
} else
return false;
break;
case Intrinsic::ppc_altivec_vcmpequq:
case Intrinsic::ppc_altivec_vcmpgtsq:
case Intrinsic::ppc_altivec_vcmpgtuq:
if (!Subtarget.isISA3_1())
return false;
switch (IntrinsicID) {
default:
llvm_unreachable("Unknown comparison intrinsic.");
case Intrinsic::ppc_altivec_vcmpequq:
CompareOpc = 455;
break;
case Intrinsic::ppc_altivec_vcmpgtsq:
CompareOpc = 903;
break;
case Intrinsic::ppc_altivec_vcmpgtuq:
CompareOpc = 647;
break;
}
break;
// VSX predicate comparisons use the same infrastructure
case Intrinsic::ppc_vsx_xvcmpeqdp_p:
case Intrinsic::ppc_vsx_xvcmpgedp_p:
case Intrinsic::ppc_vsx_xvcmpgtdp_p:
case Intrinsic::ppc_vsx_xvcmpeqsp_p:
case Intrinsic::ppc_vsx_xvcmpgesp_p:
case Intrinsic::ppc_vsx_xvcmpgtsp_p:
if (Subtarget.hasVSX()) {
switch (IntrinsicID) {
case Intrinsic::ppc_vsx_xvcmpeqdp_p:
CompareOpc = 99;
break;
case Intrinsic::ppc_vsx_xvcmpgedp_p:
CompareOpc = 115;
break;
case Intrinsic::ppc_vsx_xvcmpgtdp_p:
CompareOpc = 107;
break;
case Intrinsic::ppc_vsx_xvcmpeqsp_p:
CompareOpc = 67;
break;
case Intrinsic::ppc_vsx_xvcmpgesp_p:
CompareOpc = 83;
break;
case Intrinsic::ppc_vsx_xvcmpgtsp_p:
CompareOpc = 75;
break;
}
isDot = true;
} else
return false;
break;
// Normal Comparisons.
case Intrinsic::ppc_altivec_vcmpbfp:
CompareOpc = 966;
break;
case Intrinsic::ppc_altivec_vcmpeqfp:
CompareOpc = 198;
break;
case Intrinsic::ppc_altivec_vcmpequb:
CompareOpc = 6;
break;
case Intrinsic::ppc_altivec_vcmpequh:
CompareOpc = 70;
break;
case Intrinsic::ppc_altivec_vcmpequw:
CompareOpc = 134;
break;
case Intrinsic::ppc_altivec_vcmpequd:
if (Subtarget.hasP8Altivec())
CompareOpc = 199;
else
return false;
break;
case Intrinsic::ppc_altivec_vcmpneb:
case Intrinsic::ppc_altivec_vcmpneh:
case Intrinsic::ppc_altivec_vcmpnew:
case Intrinsic::ppc_altivec_vcmpnezb:
case Intrinsic::ppc_altivec_vcmpnezh:
case Intrinsic::ppc_altivec_vcmpnezw:
if (Subtarget.hasP9Altivec())
switch (IntrinsicID) {
default:
llvm_unreachable("Unknown comparison intrinsic.");
case Intrinsic::ppc_altivec_vcmpneb:
CompareOpc = 7;
break;
case Intrinsic::ppc_altivec_vcmpneh:
CompareOpc = 71;
break;
case Intrinsic::ppc_altivec_vcmpnew:
CompareOpc = 135;
break;
case Intrinsic::ppc_altivec_vcmpnezb:
CompareOpc = 263;
break;
case Intrinsic::ppc_altivec_vcmpnezh:
CompareOpc = 327;
break;
case Intrinsic::ppc_altivec_vcmpnezw:
CompareOpc = 391;
break;
}
else
return false;
break;
case Intrinsic::ppc_altivec_vcmpgefp:
CompareOpc = 454;
break;
case Intrinsic::ppc_altivec_vcmpgtfp:
CompareOpc = 710;
break;
case Intrinsic::ppc_altivec_vcmpgtsb:
CompareOpc = 774;
break;
case Intrinsic::ppc_altivec_vcmpgtsh:
CompareOpc = 838;
break;
case Intrinsic::ppc_altivec_vcmpgtsw:
CompareOpc = 902;
break;
case Intrinsic::ppc_altivec_vcmpgtsd:
if (Subtarget.hasP8Altivec())
CompareOpc = 967;
else
return false;
break;
case Intrinsic::ppc_altivec_vcmpgtub:
CompareOpc = 518;
break;
case Intrinsic::ppc_altivec_vcmpgtuh:
CompareOpc = 582;
break;
case Intrinsic::ppc_altivec_vcmpgtuw:
CompareOpc = 646;
break;
case Intrinsic::ppc_altivec_vcmpgtud:
if (Subtarget.hasP8Altivec())
CompareOpc = 711;
else
return false;
break;
case Intrinsic::ppc_altivec_vcmpequq_p:
case Intrinsic::ppc_altivec_vcmpgtsq_p:
case Intrinsic::ppc_altivec_vcmpgtuq_p:
if (!Subtarget.isISA3_1())
return false;
switch (IntrinsicID) {
default:
llvm_unreachable("Unknown comparison intrinsic.");
case Intrinsic::ppc_altivec_vcmpequq_p:
CompareOpc = 455;
break;
case Intrinsic::ppc_altivec_vcmpgtsq_p:
CompareOpc = 903;
break;
case Intrinsic::ppc_altivec_vcmpgtuq_p:
CompareOpc = 647;
break;
}
isDot = true;
break;
}
return true;
}
/// LowerINTRINSIC_WO_CHAIN - If this is an intrinsic that we want to custom
/// lower, do it, otherwise return null.
SDValue PPCTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op,
SelectionDAG &DAG) const {
unsigned IntrinsicID =
cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
SDLoc dl(Op);
switch (IntrinsicID) {
case Intrinsic::thread_pointer:
// Reads the thread pointer register, used for __builtin_thread_pointer.
if (Subtarget.isPPC64())
return DAG.getRegister(PPC::X13, MVT::i64);
return DAG.getRegister(PPC::R2, MVT::i32);
case Intrinsic::ppc_mma_disassemble_acc:
case Intrinsic::ppc_vsx_disassemble_pair: {
int NumVecs = 2;
SDValue WideVec = Op.getOperand(1);
if (IntrinsicID == Intrinsic::ppc_mma_disassemble_acc) {
NumVecs = 4;
WideVec = DAG.getNode(PPCISD::XXMFACC, dl, MVT::v512i1, WideVec);
}
SmallVector<SDValue, 4> RetOps;
for (int VecNo = 0; VecNo < NumVecs; VecNo++) {
SDValue Extract = DAG.getNode(
PPCISD::EXTRACT_VSX_REG, dl, MVT::v16i8, WideVec,
DAG.getConstant(Subtarget.isLittleEndian() ? NumVecs - 1 - VecNo
: VecNo,
dl, getPointerTy(DAG.getDataLayout())));
RetOps.push_back(Extract);
}
return DAG.getMergeValues(RetOps, dl);
}
case Intrinsic::ppc_unpack_longdouble: {
auto *Idx = dyn_cast<ConstantSDNode>(Op.getOperand(2));
assert(Idx && (Idx->getSExtValue() == 0 || Idx->getSExtValue() == 1) &&
"Argument of long double unpack must be 0 or 1!");
return DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::f64, Op.getOperand(1),
DAG.getConstant(!!(Idx->getSExtValue()), dl,
Idx->getValueType(0)));
}
case Intrinsic::ppc_compare_exp_lt:
case Intrinsic::ppc_compare_exp_gt:
case Intrinsic::ppc_compare_exp_eq:
case Intrinsic::ppc_compare_exp_uo: {
unsigned Pred;
switch (IntrinsicID) {
case Intrinsic::ppc_compare_exp_lt:
Pred = PPC::PRED_LT;
break;
case Intrinsic::ppc_compare_exp_gt:
Pred = PPC::PRED_GT;
break;
case Intrinsic::ppc_compare_exp_eq:
Pred = PPC::PRED_EQ;
break;
case Intrinsic::ppc_compare_exp_uo:
Pred = PPC::PRED_UN;
break;
}
return SDValue(
DAG.getMachineNode(
PPC::SELECT_CC_I4, dl, MVT::i32,
{SDValue(DAG.getMachineNode(PPC::XSCMPEXPDP, dl, MVT::i32,
Op.getOperand(1), Op.getOperand(2)),
0),
DAG.getConstant(1, dl, MVT::i32), DAG.getConstant(0, dl, MVT::i32),
DAG.getTargetConstant(Pred, dl, MVT::i32)}),
0);
}
case Intrinsic::ppc_test_data_class_d:
case Intrinsic::ppc_test_data_class_f: {
unsigned CmprOpc = PPC::XSTSTDCDP;
if (IntrinsicID == Intrinsic::ppc_test_data_class_f)
CmprOpc = PPC::XSTSTDCSP;
return SDValue(
DAG.getMachineNode(
PPC::SELECT_CC_I4, dl, MVT::i32,
{SDValue(DAG.getMachineNode(CmprOpc, dl, MVT::i32, Op.getOperand(2),
Op.getOperand(1)),
0),
DAG.getConstant(1, dl, MVT::i32), DAG.getConstant(0, dl, MVT::i32),
DAG.getTargetConstant(PPC::PRED_EQ, dl, MVT::i32)}),
0);
}
case Intrinsic::ppc_convert_f128_to_ppcf128:
case Intrinsic::ppc_convert_ppcf128_to_f128: {
RTLIB::Libcall LC = IntrinsicID == Intrinsic::ppc_convert_ppcf128_to_f128
? RTLIB::CONVERT_PPCF128_F128
: RTLIB::CONVERT_F128_PPCF128;
MakeLibCallOptions CallOptions;
std::pair<SDValue, SDValue> Result =
makeLibCall(DAG, LC, Op.getValueType(), Op.getOperand(1), CallOptions,
dl, SDValue());
return Result.first;
}
}
// If this is a lowered altivec predicate compare, CompareOpc is set to the
// opcode number of the comparison.
int CompareOpc;
bool isDot;
if (!getVectorCompareInfo(Op, CompareOpc, isDot, Subtarget))
return SDValue(); // Don't custom lower most intrinsics.
// If this is a non-dot comparison, make the VCMP node and we are done.
if (!isDot) {
SDValue Tmp = DAG.getNode(PPCISD::VCMP, dl, Op.getOperand(2).getValueType(),
Op.getOperand(1), Op.getOperand(2),
DAG.getConstant(CompareOpc, dl, MVT::i32));
return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Tmp);
}
// Create the PPCISD altivec 'dot' comparison node.
SDValue Ops[] = {
Op.getOperand(2), // LHS
Op.getOperand(3), // RHS
DAG.getConstant(CompareOpc, dl, MVT::i32)
};
EVT VTs[] = { Op.getOperand(2).getValueType(), MVT::Glue };
SDValue CompNode = DAG.getNode(PPCISD::VCMP_rec, dl, VTs, Ops);
// Now that we have the comparison, emit a copy from the CR to a GPR.
// This is flagged to the above dot comparison.
SDValue Flags = DAG.getNode(PPCISD::MFOCRF, dl, MVT::i32,
DAG.getRegister(PPC::CR6, MVT::i32),
CompNode.getValue(1));
// Unpack the result based on how the target uses it.
unsigned BitNo; // Bit # of CR6.
bool InvertBit; // Invert result?
switch (cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue()) {
default: // Can't happen, don't crash on invalid number though.
case 0: // Return the value of the EQ bit of CR6.
BitNo = 0; InvertBit = false;
break;
case 1: // Return the inverted value of the EQ bit of CR6.
BitNo = 0; InvertBit = true;
break;
case 2: // Return the value of the LT bit of CR6.
BitNo = 2; InvertBit = false;
break;
case 3: // Return the inverted value of the LT bit of CR6.
BitNo = 2; InvertBit = true;
break;
}
// Shift the bit into the low position.
Flags = DAG.getNode(ISD::SRL, dl, MVT::i32, Flags,
DAG.getConstant(8 - (3 - BitNo), dl, MVT::i32));
// Isolate the bit.
Flags = DAG.getNode(ISD::AND, dl, MVT::i32, Flags,
DAG.getConstant(1, dl, MVT::i32));
// If we are supposed to, toggle the bit.
if (InvertBit)
Flags = DAG.getNode(ISD::XOR, dl, MVT::i32, Flags,
DAG.getConstant(1, dl, MVT::i32));
return Flags;
}
SDValue PPCTargetLowering::LowerINTRINSIC_VOID(SDValue Op,
SelectionDAG &DAG) const {
// SelectionDAGBuilder::visitTargetIntrinsic may insert one extra chain to
// the beginning of the argument list.
int ArgStart = isa<ConstantSDNode>(Op.getOperand(0)) ? 0 : 1;
SDLoc DL(Op);
switch (cast<ConstantSDNode>(Op.getOperand(ArgStart))->getZExtValue()) {
case Intrinsic::ppc_cfence: {
assert(ArgStart == 1 && "llvm.ppc.cfence must carry a chain argument.");
assert(Subtarget.isPPC64() && "Only 64-bit is supported for now.");
SDValue Val = Op.getOperand(ArgStart + 1);
EVT Ty = Val.getValueType();
if (Ty == MVT::i128) {
// FIXME: Testing one of two paired registers is sufficient to guarantee
// ordering?
Val = DAG.getNode(ISD::TRUNCATE, DL, MVT::i64, Val);
}
return SDValue(
DAG.getMachineNode(PPC::CFENCE8, DL, MVT::Other,
DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, Val),
Op.getOperand(0)),
0);
}
default:
break;
}
return SDValue();
}
// Lower scalar BSWAP64 to xxbrd.
SDValue PPCTargetLowering::LowerBSWAP(SDValue Op, SelectionDAG &DAG) const {
SDLoc dl(Op);
if (!Subtarget.isPPC64())
return Op;
// MTVSRDD
Op = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v2i64, Op.getOperand(0),
Op.getOperand(0));
// XXBRD
Op = DAG.getNode(ISD::BSWAP, dl, MVT::v2i64, Op);
// MFVSRD
int VectorIndex = 0;
if (Subtarget.isLittleEndian())
VectorIndex = 1;
Op = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i64, Op,
DAG.getTargetConstant(VectorIndex, dl, MVT::i32));
return Op;
}
// ATOMIC_CMP_SWAP for i8/i16 needs to zero-extend its input since it will be
// compared to a value that is atomically loaded (atomic loads zero-extend).
SDValue PPCTargetLowering::LowerATOMIC_CMP_SWAP(SDValue Op,
SelectionDAG &DAG) const {
assert(Op.getOpcode() == ISD::ATOMIC_CMP_SWAP &&
"Expecting an atomic compare-and-swap here.");
SDLoc dl(Op);
auto *AtomicNode = cast<AtomicSDNode>(Op.getNode());
EVT MemVT = AtomicNode->getMemoryVT();
if (MemVT.getSizeInBits() >= 32)
return Op;
SDValue CmpOp = Op.getOperand(2);
// If this is already correctly zero-extended, leave it alone.
auto HighBits = APInt::getHighBitsSet(32, 32 - MemVT.getSizeInBits());
if (DAG.MaskedValueIsZero(CmpOp, HighBits))
return Op;
// Clear the high bits of the compare operand.
unsigned MaskVal = (1 << MemVT.getSizeInBits()) - 1;
SDValue NewCmpOp =
DAG.getNode(ISD::AND, dl, MVT::i32, CmpOp,
DAG.getConstant(MaskVal, dl, MVT::i32));
// Replace the existing compare operand with the properly zero-extended one.
SmallVector<SDValue, 4> Ops;
for (int i = 0, e = AtomicNode->getNumOperands(); i < e; i++)
Ops.push_back(AtomicNode->getOperand(i));
Ops[2] = NewCmpOp;
MachineMemOperand *MMO = AtomicNode->getMemOperand();
SDVTList Tys = DAG.getVTList(MVT::i32, MVT::Other);
auto NodeTy =
(MemVT == MVT::i8) ? PPCISD::ATOMIC_CMP_SWAP_8 : PPCISD::ATOMIC_CMP_SWAP_16;
return DAG.getMemIntrinsicNode(NodeTy, dl, Tys, Ops, MemVT, MMO);
}
SDValue PPCTargetLowering::LowerATOMIC_LOAD_STORE(SDValue Op,
SelectionDAG &DAG) const {
AtomicSDNode *N = cast<AtomicSDNode>(Op.getNode());
EVT MemVT = N->getMemoryVT();
assert(MemVT.getSimpleVT() == MVT::i128 &&
"Expect quadword atomic operations");
SDLoc dl(N);
unsigned Opc = N->getOpcode();
switch (Opc) {
case ISD::ATOMIC_LOAD: {
// Lower quadword atomic load to int_ppc_atomic_load_i128 which will be
// lowered to ppc instructions by pattern matching instruction selector.
SDVTList Tys = DAG.getVTList(MVT::i64, MVT::i64, MVT::Other);
SmallVector<SDValue, 4> Ops{
N->getOperand(0),
DAG.getConstant(Intrinsic::ppc_atomic_load_i128, dl, MVT::i32)};
for (int I = 1, E = N->getNumOperands(); I < E; ++I)
Ops.push_back(N->getOperand(I));
SDValue LoadedVal = DAG.getMemIntrinsicNode(ISD::INTRINSIC_W_CHAIN, dl, Tys,
Ops, MemVT, N->getMemOperand());
SDValue ValLo = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i128, LoadedVal);
SDValue ValHi =
DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i128, LoadedVal.getValue(1));
ValHi = DAG.getNode(ISD::SHL, dl, MVT::i128, ValHi,
DAG.getConstant(64, dl, MVT::i32));
SDValue Val =
DAG.getNode(ISD::OR, dl, {MVT::i128, MVT::Other}, {ValLo, ValHi});
return DAG.getNode(ISD::MERGE_VALUES, dl, {MVT::i128, MVT::Other},
{Val, LoadedVal.getValue(2)});
}
case ISD::ATOMIC_STORE: {
// Lower quadword atomic store to int_ppc_atomic_store_i128 which will be
// lowered to ppc instructions by pattern matching instruction selector.
SDVTList Tys = DAG.getVTList(MVT::Other);
SmallVector<SDValue, 4> Ops{
N->getOperand(0),
DAG.getConstant(Intrinsic::ppc_atomic_store_i128, dl, MVT::i32)};
SDValue Val = N->getOperand(2);
SDValue ValLo = DAG.getNode(ISD::TRUNCATE, dl, MVT::i64, Val);
SDValue ValHi = DAG.getNode(ISD::SRL, dl, MVT::i128, Val,
DAG.getConstant(64, dl, MVT::i32));
ValHi = DAG.getNode(ISD::TRUNCATE, dl, MVT::i64, ValHi);
Ops.push_back(ValLo);
Ops.push_back(ValHi);
Ops.push_back(N->getOperand(1));
return DAG.getMemIntrinsicNode(ISD::INTRINSIC_VOID, dl, Tys, Ops, MemVT,
N->getMemOperand());
}
default:
llvm_unreachable("Unexpected atomic opcode");
}
}
SDValue PPCTargetLowering::LowerSCALAR_TO_VECTOR(SDValue Op,
SelectionDAG &DAG) const {
SDLoc dl(Op);
// Create a stack slot that is 16-byte aligned.
MachineFrameInfo &MFI = DAG.getMachineFunction().getFrameInfo();
int FrameIdx = MFI.CreateStackObject(16, Align(16), false);
EVT PtrVT = getPointerTy(DAG.getDataLayout());
SDValue FIdx = DAG.getFrameIndex(FrameIdx, PtrVT);
// Store the input value into Value#0 of the stack slot.
SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0), FIdx,
MachinePointerInfo());
// Load it out.
return DAG.getLoad(Op.getValueType(), dl, Store, FIdx, MachinePointerInfo());
}
SDValue PPCTargetLowering::LowerINSERT_VECTOR_ELT(SDValue Op,
SelectionDAG &DAG) const {
assert(Op.getOpcode() == ISD::INSERT_VECTOR_ELT &&
"Should only be called for ISD::INSERT_VECTOR_ELT");
ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(2));
EVT VT = Op.getValueType();
SDLoc dl(Op);
SDValue V1 = Op.getOperand(0);
SDValue V2 = Op.getOperand(1);
if (VT == MVT::v2f64 && C)
return Op;
if (Subtarget.hasP9Vector()) {
// A f32 load feeding into a v4f32 insert_vector_elt is handled in this way
// because on P10, it allows this specific insert_vector_elt load pattern to
// utilize the refactored load and store infrastructure in order to exploit
// prefixed loads.
// On targets with inexpensive direct moves (Power9 and up), a
// (insert_vector_elt v4f32:$vec, (f32 load)) is always better as an integer
// load since a single precision load will involve conversion to double
// precision on the load followed by another conversion to single precision.
if ((VT == MVT::v4f32) && (V2.getValueType() == MVT::f32) &&
(isa<LoadSDNode>(V2))) {
SDValue BitcastVector = DAG.getBitcast(MVT::v4i32, V1);
SDValue BitcastLoad = DAG.getBitcast(MVT::i32, V2);
SDValue InsVecElt =
DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v4i32, BitcastVector,
BitcastLoad, Op.getOperand(2));
return DAG.getBitcast(MVT::v4f32, InsVecElt);
}
}
if (Subtarget.isISA3_1()) {
if ((VT == MVT::v2i64 || VT == MVT::v2f64) && !Subtarget.isPPC64())
return SDValue();
// On P10, we have legal lowering for constant and variable indices for
// all vectors.
if (VT == MVT::v16i8 || VT == MVT::v8i16 || VT == MVT::v4i32 ||
VT == MVT::v2i64 || VT == MVT::v4f32 || VT == MVT::v2f64)
return Op;
}
// Before P10, we have legal lowering for constant indices but not for
// variable ones.
if (!C)
return SDValue();
// We can use MTVSRZ + VECINSERT for v8i16 and v16i8 types.
if (VT == MVT::v8i16 || VT == MVT::v16i8) {
SDValue Mtvsrz = DAG.getNode(PPCISD::MTVSRZ, dl, VT, V2);
unsigned BytesInEachElement = VT.getVectorElementType().getSizeInBits() / 8;
unsigned InsertAtElement = C->getZExtValue();
unsigned InsertAtByte = InsertAtElement * BytesInEachElement;
if (Subtarget.isLittleEndian()) {
InsertAtByte = (16 - BytesInEachElement) - InsertAtByte;
}
return DAG.getNode(PPCISD::VECINSERT, dl, VT, V1, Mtvsrz,
DAG.getConstant(InsertAtByte, dl, MVT::i32));
}
return Op;
}
SDValue PPCTargetLowering::LowerVectorLoad(SDValue Op,
SelectionDAG &DAG) const {
SDLoc dl(Op);
LoadSDNode *LN = cast<LoadSDNode>(Op.getNode());
SDValue LoadChain = LN->getChain();
SDValue BasePtr = LN->getBasePtr();
EVT VT = Op.getValueType();
if (VT != MVT::v256i1 && VT != MVT::v512i1)
return Op;
// Type v256i1 is used for pairs and v512i1 is used for accumulators.
// Here we create 2 or 4 v16i8 loads to load the pair or accumulator value in
// 2 or 4 vsx registers.
assert((VT != MVT::v512i1 || Subtarget.hasMMA()) &&
"Type unsupported without MMA");
assert((VT != MVT::v256i1 || Subtarget.pairedVectorMemops()) &&
"Type unsupported without paired vector support");
Align Alignment = LN->getAlign();
SmallVector<SDValue, 4> Loads;
SmallVector<SDValue, 4> LoadChains;
unsigned NumVecs = VT.getSizeInBits() / 128;
for (unsigned Idx = 0; Idx < NumVecs; ++Idx) {
SDValue Load =
DAG.getLoad(MVT::v16i8, dl, LoadChain, BasePtr,
LN->getPointerInfo().getWithOffset(Idx * 16),
commonAlignment(Alignment, Idx * 16),
LN->getMemOperand()->getFlags(), LN->getAAInfo());
BasePtr = DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(), BasePtr,
DAG.getConstant(16, dl, BasePtr.getValueType()));
Loads.push_back(Load);
LoadChains.push_back(Load.getValue(1));
}
if (Subtarget.isLittleEndian()) {
std::reverse(Loads.begin(), Loads.end());
std::reverse(LoadChains.begin(), LoadChains.end());
}
SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, LoadChains);
SDValue Value =
DAG.getNode(VT == MVT::v512i1 ? PPCISD::ACC_BUILD : PPCISD::PAIR_BUILD,
dl, VT, Loads);
SDValue RetOps[] = {Value, TF};
return DAG.getMergeValues(RetOps, dl);
}
SDValue PPCTargetLowering::LowerVectorStore(SDValue Op,
SelectionDAG &DAG) const {
SDLoc dl(Op);
StoreSDNode *SN = cast<StoreSDNode>(Op.getNode());
SDValue StoreChain = SN->getChain();
SDValue BasePtr = SN->getBasePtr();
SDValue Value = SN->getValue();
EVT StoreVT = Value.getValueType();
if (StoreVT != MVT::v256i1 && StoreVT != MVT::v512i1)
return Op;
// Type v256i1 is used for pairs and v512i1 is used for accumulators.
// Here we create 2 or 4 v16i8 stores to store the pair or accumulator
// underlying registers individually.
assert((StoreVT != MVT::v512i1 || Subtarget.hasMMA()) &&
"Type unsupported without MMA");
assert((StoreVT != MVT::v256i1 || Subtarget.pairedVectorMemops()) &&
"Type unsupported without paired vector support");
Align Alignment = SN->getAlign();
SmallVector<SDValue, 4> Stores;
unsigned NumVecs = 2;
if (StoreVT == MVT::v512i1) {
Value = DAG.getNode(PPCISD::XXMFACC, dl, MVT::v512i1, Value);
NumVecs = 4;
}
for (unsigned Idx = 0; Idx < NumVecs; ++Idx) {
unsigned VecNum = Subtarget.isLittleEndian() ? NumVecs - 1 - Idx : Idx;
SDValue Elt = DAG.getNode(PPCISD::EXTRACT_VSX_REG, dl, MVT::v16i8, Value,
DAG.getConstant(VecNum, dl, getPointerTy(DAG.getDataLayout())));
SDValue Store =
DAG.getStore(StoreChain, dl, Elt, BasePtr,
SN->getPointerInfo().getWithOffset(Idx * 16),
commonAlignment(Alignment, Idx * 16),
SN->getMemOperand()->getFlags(), SN->getAAInfo());
BasePtr = DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(), BasePtr,
DAG.getConstant(16, dl, BasePtr.getValueType()));
Stores.push_back(Store);
}
SDValue TF = DAG.getTokenFactor(dl, Stores);
return TF;
}
SDValue PPCTargetLowering::LowerMUL(SDValue Op, SelectionDAG &DAG) const {
SDLoc dl(Op);
if (Op.getValueType() == MVT::v4i32) {
SDValue LHS = Op.getOperand(0), RHS = Op.getOperand(1);
SDValue Zero = getCanonicalConstSplat(0, 1, MVT::v4i32, DAG, dl);
// +16 as shift amt.
SDValue Neg16 = getCanonicalConstSplat(-16, 4, MVT::v4i32, DAG, dl);
SDValue RHSSwap = // = vrlw RHS, 16
BuildIntrinsicOp(Intrinsic::ppc_altivec_vrlw, RHS, Neg16, DAG, dl);
// Shrinkify inputs to v8i16.
LHS = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, LHS);
RHS = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, RHS);
RHSSwap = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, RHSSwap);
// Low parts multiplied together, generating 32-bit results (we ignore the
// top parts).
SDValue LoProd = BuildIntrinsicOp(Intrinsic::ppc_altivec_vmulouh,
LHS, RHS, DAG, dl, MVT::v4i32);
SDValue HiProd = BuildIntrinsicOp(Intrinsic::ppc_altivec_vmsumuhm,
LHS, RHSSwap, Zero, DAG, dl, MVT::v4i32);
// Shift the high parts up 16 bits.
HiProd = BuildIntrinsicOp(Intrinsic::ppc_altivec_vslw, HiProd,
Neg16, DAG, dl);
return DAG.getNode(ISD::ADD, dl, MVT::v4i32, LoProd, HiProd);
} else if (Op.getValueType() == MVT::v16i8) {
SDValue LHS = Op.getOperand(0), RHS = Op.getOperand(1);
bool isLittleEndian = Subtarget.isLittleEndian();
// Multiply the even 8-bit parts, producing 16-bit sums.
SDValue EvenParts = BuildIntrinsicOp(Intrinsic::ppc_altivec_vmuleub,
LHS, RHS, DAG, dl, MVT::v8i16);
EvenParts = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, EvenParts);
// Multiply the odd 8-bit parts, producing 16-bit sums.
SDValue OddParts = BuildIntrinsicOp(Intrinsic::ppc_altivec_vmuloub,
LHS, RHS, DAG, dl, MVT::v8i16);
OddParts = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, OddParts);
// Merge the results together. Because vmuleub and vmuloub are
// instructions with a big-endian bias, we must reverse the
// element numbering and reverse the meaning of "odd" and "even"
// when generating little endian code.
int Ops[16];
for (unsigned i = 0; i != 8; ++i) {
if (isLittleEndian) {
Ops[i*2 ] = 2*i;
Ops[i*2+1] = 2*i+16;
} else {
Ops[i*2 ] = 2*i+1;
Ops[i*2+1] = 2*i+1+16;
}
}
if (isLittleEndian)
return DAG.getVectorShuffle(MVT::v16i8, dl, OddParts, EvenParts, Ops);
else
return DAG.getVectorShuffle(MVT::v16i8, dl, EvenParts, OddParts, Ops);
} else {
llvm_unreachable("Unknown mul to lower!");
}
}
SDValue PPCTargetLowering::LowerFP_ROUND(SDValue Op, SelectionDAG &DAG) const {
bool IsStrict = Op->isStrictFPOpcode();
if (Op.getOperand(IsStrict ? 1 : 0).getValueType() == MVT::f128 &&
!Subtarget.hasP9Vector())
return SDValue();
return Op;
}
// Custom lowering for fpext vf32 to v2f64
SDValue PPCTargetLowering::LowerFP_EXTEND(SDValue Op, SelectionDAG &DAG) const {
assert(Op.getOpcode() == ISD::FP_EXTEND &&
"Should only be called for ISD::FP_EXTEND");
// FIXME: handle extends from half precision float vectors on P9.
// We only want to custom lower an extend from v2f32 to v2f64.
if (Op.getValueType() != MVT::v2f64 ||
Op.getOperand(0).getValueType() != MVT::v2f32)
return SDValue();
SDLoc dl(Op);
SDValue Op0 = Op.getOperand(0);
switch (Op0.getOpcode()) {
default:
return SDValue();
case ISD::EXTRACT_SUBVECTOR: {
assert(Op0.getNumOperands() == 2 &&
isa<ConstantSDNode>(Op0->getOperand(1)) &&
"Node should have 2 operands with second one being a constant!");
if (Op0.getOperand(0).getValueType() != MVT::v4f32)
return SDValue();
// Custom lower is only done for high or low doubleword.
int Idx = cast<ConstantSDNode>(Op0.getOperand(1))->getZExtValue();
if (Idx % 2 != 0)
return SDValue();
// Since input is v4f32, at this point Idx is either 0 or 2.
// Shift to get the doubleword position we want.
int DWord = Idx >> 1;
// High and low word positions are different on little endian.
if (Subtarget.isLittleEndian())
DWord ^= 0x1;
return DAG.getNode(PPCISD::FP_EXTEND_HALF, dl, MVT::v2f64,
Op0.getOperand(0), DAG.getConstant(DWord, dl, MVT::i32));
}
case ISD::FADD:
case ISD::FMUL:
case ISD::FSUB: {
SDValue NewLoad[2];
for (unsigned i = 0, ie = Op0.getNumOperands(); i != ie; ++i) {
// Ensure both input are loads.
SDValue LdOp = Op0.getOperand(i);
if (LdOp.getOpcode() != ISD::LOAD)
return SDValue();
// Generate new load node.
LoadSDNode *LD = cast<LoadSDNode>(LdOp);
SDValue LoadOps[] = {LD->getChain(), LD->getBasePtr()};
NewLoad[i] = DAG.getMemIntrinsicNode(
PPCISD::LD_VSX_LH, dl, DAG.getVTList(MVT::v4f32, MVT::Other), LoadOps,
LD->getMemoryVT(), LD->getMemOperand());
}
SDValue NewOp =
DAG.getNode(Op0.getOpcode(), SDLoc(Op0), MVT::v4f32, NewLoad[0],
NewLoad[1], Op0.getNode()->getFlags());
return DAG.getNode(PPCISD::FP_EXTEND_HALF, dl, MVT::v2f64, NewOp,
DAG.getConstant(0, dl, MVT::i32));
}
case ISD::LOAD: {
LoadSDNode *LD = cast<LoadSDNode>(Op0);
SDValue LoadOps[] = {LD->getChain(), LD->getBasePtr()};
SDValue NewLd = DAG.getMemIntrinsicNode(
PPCISD::LD_VSX_LH, dl, DAG.getVTList(MVT::v4f32, MVT::Other), LoadOps,
LD->getMemoryVT(), LD->getMemOperand());
return DAG.getNode(PPCISD::FP_EXTEND_HALF, dl, MVT::v2f64, NewLd,
DAG.getConstant(0, dl, MVT::i32));
}
}
llvm_unreachable("ERROR:Should return for all cases within swtich.");
}
/// LowerOperation - Provide custom lowering hooks for some operations.
///
SDValue PPCTargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
switch (Op.getOpcode()) {
default: llvm_unreachable("Wasn't expecting to be able to lower this!");
case ISD::ConstantPool: return LowerConstantPool(Op, DAG);
case ISD::BlockAddress: return LowerBlockAddress(Op, DAG);
case ISD::GlobalAddress: return LowerGlobalAddress(Op, DAG);
case ISD::GlobalTLSAddress: return LowerGlobalTLSAddress(Op, DAG);
case ISD::JumpTable: return LowerJumpTable(Op, DAG);
case ISD::STRICT_FSETCC:
case ISD::STRICT_FSETCCS:
case ISD::SETCC: return LowerSETCC(Op, DAG);
case ISD::INIT_TRAMPOLINE: return LowerINIT_TRAMPOLINE(Op, DAG);
case ISD::ADJUST_TRAMPOLINE: return LowerADJUST_TRAMPOLINE(Op, DAG);
case ISD::INLINEASM:
case ISD::INLINEASM_BR: return LowerINLINEASM(Op, DAG);
// Variable argument lowering.
case ISD::VASTART: return LowerVASTART(Op, DAG);
case ISD::VAARG: return LowerVAARG(Op, DAG);
case ISD::VACOPY: return LowerVACOPY(Op, DAG);
case ISD::STACKRESTORE: return LowerSTACKRESTORE(Op, DAG);
case ISD::DYNAMIC_STACKALLOC: return LowerDYNAMIC_STACKALLOC(Op, DAG);
case ISD::GET_DYNAMIC_AREA_OFFSET:
return LowerGET_DYNAMIC_AREA_OFFSET(Op, DAG);
// Exception handling lowering.
case ISD::EH_DWARF_CFA: return LowerEH_DWARF_CFA(Op, DAG);
case ISD::EH_SJLJ_SETJMP: return lowerEH_SJLJ_SETJMP(Op, DAG);
case ISD::EH_SJLJ_LONGJMP: return lowerEH_SJLJ_LONGJMP(Op, DAG);
case ISD::LOAD: return LowerLOAD(Op, DAG);
case ISD::STORE: return LowerSTORE(Op, DAG);
case ISD::TRUNCATE: return LowerTRUNCATE(Op, DAG);
case ISD::SELECT_CC: return LowerSELECT_CC(Op, DAG);
case ISD::STRICT_FP_TO_UINT:
case ISD::STRICT_FP_TO_SINT:
case ISD::FP_TO_UINT:
case ISD::FP_TO_SINT: return LowerFP_TO_INT(Op, DAG, SDLoc(Op));
case ISD::STRICT_UINT_TO_FP:
case ISD::STRICT_SINT_TO_FP:
case ISD::UINT_TO_FP:
case ISD::SINT_TO_FP: return LowerINT_TO_FP(Op, DAG);
case ISD::FLT_ROUNDS_: return LowerFLT_ROUNDS_(Op, DAG);
// Lower 64-bit shifts.
case ISD::SHL_PARTS: return LowerSHL_PARTS(Op, DAG);
case ISD::SRL_PARTS: return LowerSRL_PARTS(Op, DAG);
case ISD::SRA_PARTS: return LowerSRA_PARTS(Op, DAG);
case ISD::FSHL: return LowerFunnelShift(Op, DAG);
case ISD::FSHR: return LowerFunnelShift(Op, DAG);
// Vector-related lowering.
case ISD::BUILD_VECTOR: return LowerBUILD_VECTOR(Op, DAG);
case ISD::VECTOR_SHUFFLE: return LowerVECTOR_SHUFFLE(Op, DAG);
case ISD::INTRINSIC_WO_CHAIN: return LowerINTRINSIC_WO_CHAIN(Op, DAG);
case ISD::SCALAR_TO_VECTOR: return LowerSCALAR_TO_VECTOR(Op, DAG);
case ISD::INSERT_VECTOR_ELT: return LowerINSERT_VECTOR_ELT(Op, DAG);
case ISD::MUL: return LowerMUL(Op, DAG);
case ISD::FP_EXTEND: return LowerFP_EXTEND(Op, DAG);
case ISD::STRICT_FP_ROUND:
case ISD::FP_ROUND:
return LowerFP_ROUND(Op, DAG);
case ISD::ROTL: return LowerROTL(Op, DAG);
// For counter-based loop handling.
case ISD::INTRINSIC_W_CHAIN: return SDValue();
case ISD::BITCAST: return LowerBITCAST(Op, DAG);
// Frame & Return address.
case ISD::RETURNADDR: return LowerRETURNADDR(Op, DAG);
case ISD::FRAMEADDR: return LowerFRAMEADDR(Op, DAG);
case ISD::INTRINSIC_VOID:
return LowerINTRINSIC_VOID(Op, DAG);
case ISD::BSWAP:
return LowerBSWAP(Op, DAG);
case ISD::ATOMIC_CMP_SWAP:
return LowerATOMIC_CMP_SWAP(Op, DAG);
case ISD::ATOMIC_STORE:
return LowerATOMIC_LOAD_STORE(Op, DAG);
}
}
void PPCTargetLowering::ReplaceNodeResults(SDNode *N,
SmallVectorImpl<SDValue>&Results,
SelectionDAG &DAG) const {
SDLoc dl(N);
switch (N->getOpcode()) {
default:
llvm_unreachable("Do not know how to custom type legalize this operation!");
case ISD::ATOMIC_LOAD: {
SDValue Res = LowerATOMIC_LOAD_STORE(SDValue(N, 0), DAG);
Results.push_back(Res);
Results.push_back(Res.getValue(1));
break;
}
case ISD::READCYCLECOUNTER: {
SDVTList VTs = DAG.getVTList(MVT::i32, MVT::i32, MVT::Other);
SDValue RTB = DAG.getNode(PPCISD::READ_TIME_BASE, dl, VTs, N->getOperand(0));
Results.push_back(
DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, RTB, RTB.getValue(1)));
Results.push_back(RTB.getValue(2));
break;
}
case ISD::INTRINSIC_W_CHAIN: {
if (cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() !=
Intrinsic::loop_decrement)
break;
assert(N->getValueType(0) == MVT::i1 &&
"Unexpected result type for CTR decrement intrinsic");
EVT SVT = getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(),
N->getValueType(0));
SDVTList VTs = DAG.getVTList(SVT, MVT::Other);
SDValue NewInt = DAG.getNode(N->getOpcode(), dl, VTs, N->getOperand(0),
N->getOperand(1));
Results.push_back(DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, NewInt));
Results.push_back(NewInt.getValue(1));
break;
}
case ISD::INTRINSIC_WO_CHAIN: {
switch (cast<ConstantSDNode>(N->getOperand(0))->getZExtValue()) {
case Intrinsic::ppc_pack_longdouble:
Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, MVT::ppcf128,
N->getOperand(2), N->getOperand(1)));
break;
case Intrinsic::ppc_convert_f128_to_ppcf128:
Results.push_back(LowerINTRINSIC_WO_CHAIN(SDValue(N, 0), DAG));
break;
}
break;
}
case ISD::VAARG: {
if (!Subtarget.isSVR4ABI() || Subtarget.isPPC64())
return;
EVT VT = N->getValueType(0);
if (VT == MVT::i64) {
SDValue NewNode = LowerVAARG(SDValue(N, 1), DAG);
Results.push_back(NewNode);
Results.push_back(NewNode.getValue(1));
}
return;
}
case ISD::STRICT_FP_TO_SINT:
case ISD::STRICT_FP_TO_UINT:
case ISD::FP_TO_SINT:
case ISD::FP_TO_UINT: {
// LowerFP_TO_INT() can only handle f32 and f64.
if (N->getOperand(N->isStrictFPOpcode() ? 1 : 0).getValueType() ==
MVT::ppcf128)
return;
SDValue LoweredValue = LowerFP_TO_INT(SDValue(N, 0), DAG, dl);
Results.push_back(LoweredValue);
if (N->isStrictFPOpcode())
Results.push_back(LoweredValue.getValue(1));
return;
}
case ISD::TRUNCATE: {
if (!N->getValueType(0).isVector())
return;
SDValue Lowered = LowerTRUNCATEVector(SDValue(N, 0), DAG);
if (Lowered)
Results.push_back(Lowered);
return;
}
case ISD::FSHL:
case ISD::FSHR:
// Don't handle funnel shifts here.
return;
case ISD::BITCAST:
// Don't handle bitcast here.
return;
case ISD::FP_EXTEND:
SDValue Lowered = LowerFP_EXTEND(SDValue(N, 0), DAG);
if (Lowered)
Results.push_back(Lowered);
return;
}
}
//===----------------------------------------------------------------------===//
// Other Lowering Code
//===----------------------------------------------------------------------===//
static Instruction *callIntrinsic(IRBuilderBase &Builder, Intrinsic::ID Id) {
Module *M = Builder.GetInsertBlock()->getParent()->getParent();
Function *Func = Intrinsic::getDeclaration(M, Id);
return Builder.CreateCall(Func, {});
}
// The mappings for emitLeading/TrailingFence is taken from
// http://www.cl.cam.ac.uk/~pes20/cpp/cpp0xmappings.html
Instruction *PPCTargetLowering::emitLeadingFence(IRBuilderBase &Builder,
Instruction *Inst,
AtomicOrdering Ord) const {
if (Ord == AtomicOrdering::SequentiallyConsistent)
return callIntrinsic(Builder, Intrinsic::ppc_sync);
if (isReleaseOrStronger(Ord))
return callIntrinsic(Builder, Intrinsic::ppc_lwsync);
return nullptr;
}
Instruction *PPCTargetLowering::emitTrailingFence(IRBuilderBase &Builder,
Instruction *Inst,
AtomicOrdering Ord) const {
if (Inst->hasAtomicLoad() && isAcquireOrStronger(Ord)) {
// See http://www.cl.cam.ac.uk/~pes20/cpp/cpp0xmappings.html and
// http://www.rdrop.com/users/paulmck/scalability/paper/N2745r.2011.03.04a.html
// and http://www.cl.cam.ac.uk/~pes20/cppppc/ for justification.
if (isa<LoadInst>(Inst) && Subtarget.isPPC64())
return Builder.CreateCall(
Intrinsic::getDeclaration(
Builder.GetInsertBlock()->getParent()->getParent(),
Intrinsic::ppc_cfence, {Inst->getType()}),
{Inst});
// FIXME: Can use isync for rmw operation.
return callIntrinsic(Builder, Intrinsic::ppc_lwsync);
}
return nullptr;
}
MachineBasicBlock *
PPCTargetLowering::EmitAtomicBinary(MachineInstr &MI, MachineBasicBlock *BB,
unsigned AtomicSize,
unsigned BinOpcode,
unsigned CmpOpcode,
unsigned CmpPred) const {
// This also handles ATOMIC_SWAP, indicated by BinOpcode==0.
const TargetInstrInfo *TII = Subtarget.getInstrInfo();
auto LoadMnemonic = PPC::LDARX;
auto StoreMnemonic = PPC::STDCX;
switch (AtomicSize) {
default:
llvm_unreachable("Unexpected size of atomic entity");
case 1:
LoadMnemonic = PPC::LBARX;
StoreMnemonic = PPC::STBCX;
assert(Subtarget.hasPartwordAtomics() && "Call this only with size >=4");
break;
case 2:
LoadMnemonic = PPC::LHARX;
StoreMnemonic = PPC::STHCX;
assert(Subtarget.hasPartwordAtomics() && "Call this only with size >=4");
break;
case 4:
LoadMnemonic = PPC::LWARX;
StoreMnemonic = PPC::STWCX;
break;
case 8:
LoadMnemonic = PPC::LDARX;
StoreMnemonic = PPC::STDCX;
break;
}
const BasicBlock *LLVM_BB = BB->getBasicBlock();
MachineFunction *F = BB->getParent();
MachineFunction::iterator It = ++BB->getIterator();
Register dest = MI.getOperand(0).getReg();
Register ptrA = MI.getOperand(1).getReg();
Register ptrB = MI.getOperand(2).getReg();
Register incr = MI.getOperand(3).getReg();
DebugLoc dl = MI.getDebugLoc();
MachineBasicBlock *loopMBB = F->CreateMachineBasicBlock(LLVM_BB);
MachineBasicBlock *loop2MBB =
CmpOpcode ? F->CreateMachineBasicBlock(LLVM_BB) : nullptr;
MachineBasicBlock *exitMBB = F->CreateMachineBasicBlock(LLVM_BB);
F->insert(It, loopMBB);
if (CmpOpcode)
F->insert(It, loop2MBB);
F->insert(It, exitMBB);
exitMBB->splice(exitMBB->begin(), BB,
std::next(MachineBasicBlock::iterator(MI)), BB->end());
exitMBB->transferSuccessorsAndUpdatePHIs(BB);
MachineRegisterInfo &RegInfo = F->getRegInfo();
Register TmpReg = (!BinOpcode) ? incr :
RegInfo.createVirtualRegister( AtomicSize == 8 ? &PPC::G8RCRegClass
: &PPC::GPRCRegClass);
// thisMBB:
// ...
// fallthrough --> loopMBB
BB->addSuccessor(loopMBB);
// loopMBB:
// l[wd]arx dest, ptr
// add r0, dest, incr
// st[wd]cx. r0, ptr
// bne- loopMBB
// fallthrough --> exitMBB
// For max/min...
// loopMBB:
// l[wd]arx dest, ptr
// cmpl?[wd] incr, dest
// bgt exitMBB
// loop2MBB:
// st[wd]cx. dest, ptr
// bne- loopMBB
// fallthrough --> exitMBB
BB = loopMBB;
BuildMI(BB, dl, TII->get(LoadMnemonic), dest)
.addReg(ptrA).addReg(ptrB);
if (BinOpcode)
BuildMI(BB, dl, TII->get(BinOpcode), TmpReg).addReg(incr).addReg(dest);
if (CmpOpcode) {
// Signed comparisons of byte or halfword values must be sign-extended.
if (CmpOpcode == PPC::CMPW && AtomicSize < 4) {
Register ExtReg = RegInfo.createVirtualRegister(&PPC::GPRCRegClass);
BuildMI(BB, dl, TII->get(AtomicSize == 1 ? PPC::EXTSB : PPC::EXTSH),
ExtReg).addReg(dest);
BuildMI(BB, dl, TII->get(CmpOpcode), PPC::CR0)
.addReg(incr).addReg(ExtReg);
} else
BuildMI(BB, dl, TII->get(CmpOpcode), PPC::CR0)
.addReg(incr).addReg(dest);
BuildMI(BB, dl, TII->get(PPC::BCC))
.addImm(CmpPred).addReg(PPC::CR0).addMBB(exitMBB);
BB->addSuccessor(loop2MBB);
BB->addSuccessor(exitMBB);
BB = loop2MBB;
}
BuildMI(BB, dl, TII->get(StoreMnemonic))
.addReg(TmpReg).addReg(ptrA).addReg(ptrB);
BuildMI(BB, dl, TII->get(PPC::BCC))
.addImm(PPC::PRED_NE).addReg(PPC::CR0).addMBB(loopMBB);
BB->addSuccessor(loopMBB);
BB->addSuccessor(exitMBB);
// exitMBB:
// ...
BB = exitMBB;
return BB;
}
static bool isSignExtended(MachineInstr &MI, const PPCInstrInfo *TII) {
switch(MI.getOpcode()) {
default:
return false;
case PPC::COPY:
return TII->isSignExtended(MI);
case PPC::LHA:
case PPC::LHA8:
case PPC::LHAU:
case PPC::LHAU8:
case PPC::LHAUX:
case PPC::LHAUX8:
case PPC::LHAX:
case PPC::LHAX8:
case PPC::LWA:
case PPC::LWAUX:
case PPC::LWAX:
case PPC::LWAX_32:
case PPC::LWA_32:
case PPC::PLHA:
case PPC::PLHA8:
case PPC::PLHA8pc:
case PPC::PLHApc:
case PPC::PLWA:
case PPC::PLWA8:
case PPC::PLWA8pc:
case PPC::PLWApc:
case PPC::EXTSB:
case PPC::EXTSB8:
case PPC::EXTSB8_32_64:
case PPC::EXTSB8_rec:
case PPC::EXTSB_rec:
case PPC::EXTSH:
case PPC::EXTSH8:
case PPC::EXTSH8_32_64:
case PPC::EXTSH8_rec:
case PPC::EXTSH_rec:
case PPC::EXTSW:
case PPC::EXTSWSLI:
case PPC::EXTSWSLI_32_64:
case PPC::EXTSWSLI_32_64_rec:
case PPC::EXTSWSLI_rec:
case PPC::EXTSW_32:
case PPC::EXTSW_32_64:
case PPC::EXTSW_32_64_rec:
case PPC::EXTSW_rec:
case PPC::SRAW:
case PPC::SRAWI:
case PPC::SRAWI_rec:
case PPC::SRAW_rec:
return true;
}
return false;
}
MachineBasicBlock *PPCTargetLowering::EmitPartwordAtomicBinary(
MachineInstr &MI, MachineBasicBlock *BB,
bool is8bit, // operation
unsigned BinOpcode, unsigned CmpOpcode, unsigned CmpPred) const {
// This also handles ATOMIC_SWAP, indicated by BinOpcode==0.
const PPCInstrInfo *TII = Subtarget.getInstrInfo();
// If this is a signed comparison and the value being compared is not known
// to be sign extended, sign extend it here.
DebugLoc dl = MI.getDebugLoc();
MachineFunction *F = BB->getParent();
MachineRegisterInfo &RegInfo = F->getRegInfo();
Register incr = MI.getOperand(3).getReg();
bool IsSignExtended = Register::isVirtualRegister(incr) &&
isSignExtended(*RegInfo.getVRegDef(incr), TII);
if (CmpOpcode == PPC::CMPW && !IsSignExtended) {
Register ValueReg = RegInfo.createVirtualRegister(&PPC::GPRCRegClass);
BuildMI(*BB, MI, dl, TII->get(is8bit ? PPC::EXTSB : PPC::EXTSH), ValueReg)
.addReg(MI.getOperand(3).getReg());
MI.getOperand(3).setReg(ValueReg);
}
// If we support part-word atomic mnemonics, just use them
if (Subtarget.hasPartwordAtomics())
return EmitAtomicBinary(MI, BB, is8bit ? 1 : 2, BinOpcode, CmpOpcode,
CmpPred);
// In 64 bit mode we have to use 64 bits for addresses, even though the
// lwarx/stwcx are 32 bits. With the 32-bit atomics we can use address
// registers without caring whether they're 32 or 64, but here we're
// doing actual arithmetic on the addresses.
bool is64bit = Subtarget.isPPC64();
bool isLittleEndian = Subtarget.isLittleEndian();
unsigned ZeroReg = is64bit ? PPC::ZERO8 : PPC::ZERO;
const BasicBlock *LLVM_BB = BB->getBasicBlock();
MachineFunction::iterator It = ++BB->getIterator();
Register dest = MI.getOperand(0).getReg();
Register ptrA = MI.getOperand(1).getReg();
Register ptrB = MI.getOperand(2).getReg();
MachineBasicBlock *loopMBB = F->CreateMachineBasicBlock(LLVM_BB);
MachineBasicBlock *loop2MBB =
CmpOpcode ? F->CreateMachineBasicBlock(LLVM_BB) : nullptr;
MachineBasicBlock *exitMBB = F->CreateMachineBasicBlock(LLVM_BB);
F->insert(It, loopMBB);
if (CmpOpcode)
F->insert(It, loop2MBB);
F->insert(It, exitMBB);
exitMBB->splice(exitMBB->begin(), BB,
std::next(MachineBasicBlock::iterator(MI)), BB->end());
exitMBB->transferSuccessorsAndUpdatePHIs(BB);
const TargetRegisterClass *RC =
is64bit ? &PPC::G8RCRegClass : &PPC::GPRCRegClass;
const TargetRegisterClass *GPRC = &PPC::GPRCRegClass;
Register PtrReg = RegInfo.createVirtualRegister(RC);
Register Shift1Reg = RegInfo.createVirtualRegister(GPRC);
Register ShiftReg =
isLittleEndian ? Shift1Reg : RegInfo.createVirtualRegister(GPRC);
Register Incr2Reg = RegInfo.createVirtualRegister(GPRC);
Register MaskReg = RegInfo.createVirtualRegister(GPRC);
Register Mask2Reg = RegInfo.createVirtualRegister(GPRC);
Register Mask3Reg = RegInfo.createVirtualRegister(GPRC);
Register Tmp2Reg = RegInfo.createVirtualRegister(GPRC);
Register Tmp3Reg = RegInfo.createVirtualRegister(GPRC);
Register Tmp4Reg = RegInfo.createVirtualRegister(GPRC);
Register TmpDestReg = RegInfo.createVirtualRegister(GPRC);
Register SrwDestReg = RegInfo.createVirtualRegister(GPRC);
Register Ptr1Reg;
Register TmpReg =
(!BinOpcode) ? Incr2Reg : RegInfo.createVirtualRegister(GPRC);
// thisMBB:
// ...
// fallthrough --> loopMBB
BB->addSuccessor(loopMBB);
// The 4-byte load must be aligned, while a char or short may be
// anywhere in the word. Hence all this nasty bookkeeping code.
// add ptr1, ptrA, ptrB [copy if ptrA==0]
// rlwinm shift1, ptr1, 3, 27, 28 [3, 27, 27]
// xori shift, shift1, 24 [16]
// rlwinm ptr, ptr1, 0, 0, 29
// slw incr2, incr, shift
// li mask2, 255 [li mask3, 0; ori mask2, mask3, 65535]
// slw mask, mask2, shift
// loopMBB:
// lwarx tmpDest, ptr
// add tmp, tmpDest, incr2
// andc tmp2, tmpDest, mask
// and tmp3, tmp, mask
// or tmp4, tmp3, tmp2
// stwcx. tmp4, ptr
// bne- loopMBB
// fallthrough --> exitMBB
// srw SrwDest, tmpDest, shift
// rlwinm SrwDest, SrwDest, 0, 24 [16], 31
if (ptrA != ZeroReg) {
Ptr1Reg = RegInfo.createVirtualRegister(RC);
BuildMI(BB, dl, TII->get(is64bit ? PPC::ADD8 : PPC::ADD4), Ptr1Reg)
.addReg(ptrA)
.addReg(ptrB);
} else {
Ptr1Reg = ptrB;
}
// We need use 32-bit subregister to avoid mismatch register class in 64-bit
// mode.
BuildMI(BB, dl, TII->get(PPC::RLWINM), Shift1Reg)
.addReg(Ptr1Reg, 0, is64bit ? PPC::sub_32 : 0)
.addImm(3)
.addImm(27)
.addImm(is8bit ? 28 : 27);
if (!isLittleEndian)
BuildMI(BB, dl, TII->get(PPC::XORI), ShiftReg)
.addReg(Shift1Reg)
.addImm(is8bit ? 24 : 16);
if (is64bit)
BuildMI(BB, dl, TII->get(PPC::RLDICR), PtrReg)
.addReg(Ptr1Reg)
.addImm(0)
.addImm(61);
else
BuildMI(BB, dl, TII->get(PPC::RLWINM), PtrReg)
.addReg(Ptr1Reg)
.addImm(0)
.addImm(0)
.addImm(29);
BuildMI(BB, dl, TII->get(PPC::SLW), Incr2Reg).addReg(incr).addReg(ShiftReg);
if (is8bit)
BuildMI(BB, dl, TII->get(PPC::LI), Mask2Reg).addImm(255);
else {
BuildMI(BB, dl, TII->get(PPC::LI), Mask3Reg).addImm(0);
BuildMI(BB, dl, TII->get(PPC::ORI), Mask2Reg)
.addReg(Mask3Reg)
.addImm(65535);
}
BuildMI(BB, dl, TII->get(PPC::SLW), MaskReg)
.addReg(Mask2Reg)
.addReg(ShiftReg);
BB = loopMBB;
BuildMI(BB, dl, TII->get(PPC::LWARX), TmpDestReg)
.addReg(ZeroReg)
.addReg(PtrReg);
if (BinOpcode)
BuildMI(BB, dl, TII->get(BinOpcode), TmpReg)
.addReg(Incr2Reg)
.addReg(TmpDestReg);
BuildMI(BB, dl, TII->get(PPC::ANDC), Tmp2Reg)
.addReg(TmpDestReg)
.addReg(MaskReg);
BuildMI(BB, dl, TII->get(PPC::AND), Tmp3Reg).addReg(TmpReg).addReg(MaskReg);
if (CmpOpcode) {
// For unsigned comparisons, we can directly compare the shifted values.
// For signed comparisons we shift and sign extend.
Register SReg = RegInfo.createVirtualRegister(GPRC);
BuildMI(BB, dl, TII->get(PPC::AND), SReg)
.addReg(TmpDestReg)
.addReg(MaskReg);
unsigned ValueReg = SReg;
unsigned CmpReg = Incr2Reg;
if (CmpOpcode == PPC::CMPW) {
ValueReg = RegInfo.createVirtualRegister(GPRC);
BuildMI(BB, dl, TII->get(PPC::SRW), ValueReg)
.addReg(SReg)
.addReg(ShiftReg);
Register ValueSReg = RegInfo.createVirtualRegister(GPRC);
BuildMI(BB, dl, TII->get(is8bit ? PPC::EXTSB : PPC::EXTSH), ValueSReg)
.addReg(ValueReg);
ValueReg = ValueSReg;
CmpReg = incr;
}
BuildMI(BB, dl, TII->get(CmpOpcode), PPC::CR0)
.addReg(CmpReg)
.addReg(ValueReg);
BuildMI(BB, dl, TII->get(PPC::BCC))
.addImm(CmpPred)
.addReg(PPC::CR0)
.addMBB(exitMBB);
BB->addSuccessor(loop2MBB);
BB->addSuccessor(exitMBB);
BB = loop2MBB;
}
BuildMI(BB, dl, TII->get(PPC::OR), Tmp4Reg).addReg(Tmp3Reg).addReg(Tmp2Reg);
BuildMI(BB, dl, TII->get(PPC::STWCX))
.addReg(Tmp4Reg)
.addReg(ZeroReg)
.addReg(PtrReg);
BuildMI(BB, dl, TII->get(PPC::BCC))
.addImm(PPC::PRED_NE)
.addReg(PPC::CR0)
.addMBB(loopMBB);
BB->addSuccessor(loopMBB);
BB->addSuccessor(exitMBB);
// exitMBB:
// ...
BB = exitMBB;
// Since the shift amount is not a constant, we need to clear
// the upper bits with a separate RLWINM.
BuildMI(*BB, BB->begin(), dl, TII->get(PPC::RLWINM), dest)
.addReg(SrwDestReg)
.addImm(0)
.addImm(is8bit ? 24 : 16)
.addImm(31);
BuildMI(*BB, BB->begin(), dl, TII->get(PPC::SRW), SrwDestReg)
.addReg(TmpDestReg)
.addReg(ShiftReg);
return BB;
}
llvm::MachineBasicBlock *
PPCTargetLowering::emitEHSjLjSetJmp(MachineInstr &MI,
MachineBasicBlock *MBB) const {
DebugLoc DL = MI.getDebugLoc();
const TargetInstrInfo *TII = Subtarget.getInstrInfo();
const PPCRegisterInfo *TRI = Subtarget.getRegisterInfo();
MachineFunction *MF = MBB->getParent();
MachineRegisterInfo &MRI = MF->getRegInfo();
const BasicBlock *BB = MBB->getBasicBlock();
MachineFunction::iterator I = ++MBB->getIterator();
Register DstReg = MI.getOperand(0).getReg();
const TargetRegisterClass *RC = MRI.getRegClass(DstReg);
assert(TRI->isTypeLegalForClass(*RC, MVT::i32) && "Invalid destination!");
Register mainDstReg = MRI.createVirtualRegister(RC);
Register restoreDstReg = MRI.createVirtualRegister(RC);
MVT PVT = getPointerTy(MF->getDataLayout());
assert((PVT == MVT::i64 || PVT == MVT::i32) &&
"Invalid Pointer Size!");
// For v = setjmp(buf), we generate
//
// thisMBB:
// SjLjSetup mainMBB
// bl mainMBB
// v_restore = 1
// b sinkMBB
//
// mainMBB:
// buf[LabelOffset] = LR
// v_main = 0
//
// sinkMBB:
// v = phi(main, restore)
//
MachineBasicBlock *thisMBB = MBB;
MachineBasicBlock *mainMBB = MF->CreateMachineBasicBlock(BB);
MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(BB);
MF->insert(I, mainMBB);
MF->insert(I, sinkMBB);
MachineInstrBuilder MIB;
// Transfer the remainder of BB and its successor edges to sinkMBB.
sinkMBB->splice(sinkMBB->begin(), MBB,
std::next(MachineBasicBlock::iterator(MI)), MBB->end());
sinkMBB->transferSuccessorsAndUpdatePHIs(MBB);
// Note that the structure of the jmp_buf used here is not compatible
// with that used by libc, and is not designed to be. Specifically, it
// stores only those 'reserved' registers that LLVM does not otherwise
// understand how to spill. Also, by convention, by the time this
// intrinsic is called, Clang has already stored the frame address in the
// first slot of the buffer and stack address in the third. Following the
// X86 target code, we'll store the jump address in the second slot. We also
// need to save the TOC pointer (R2) to handle jumps between shared
// libraries, and that will be stored in the fourth slot. The thread
// identifier (R13) is not affected.
// thisMBB:
const int64_t LabelOffset = 1 * PVT.getStoreSize();
const int64_t TOCOffset = 3 * PVT.getStoreSize();
const int64_t BPOffset = 4 * PVT.getStoreSize();
// Prepare IP either in reg.
const TargetRegisterClass *PtrRC = getRegClassFor(PVT);
Register LabelReg = MRI.createVirtualRegister(PtrRC);
Register BufReg = MI.getOperand(1).getReg();
if (Subtarget.is64BitELFABI()) {
setUsesTOCBasePtr(*MBB->getParent());
MIB = BuildMI(*thisMBB, MI, DL, TII->get(PPC::STD))
.addReg(PPC::X2)
.addImm(TOCOffset)
.addReg(BufReg)
.cloneMemRefs(MI);
}
// Naked functions never have a base pointer, and so we use r1. For all
// other functions, this decision must be delayed until during PEI.
unsigned BaseReg;
if (MF->getFunction().hasFnAttribute(Attribute::Naked))
BaseReg = Subtarget.isPPC64() ? PPC::X1 : PPC::R1;
else
BaseReg = Subtarget.isPPC64() ? PPC::BP8 : PPC::BP;
MIB = BuildMI(*thisMBB, MI, DL,
TII->get(Subtarget.isPPC64() ? PPC::STD : PPC::STW))
.addReg(BaseReg)
.addImm(BPOffset)
.addReg(BufReg)
.cloneMemRefs(MI);
// Setup
MIB = BuildMI(*thisMBB, MI, DL, TII->get(PPC::BCLalways)).addMBB(mainMBB);
MIB.addRegMask(TRI->getNoPreservedMask());
BuildMI(*thisMBB, MI, DL, TII->get(PPC::LI), restoreDstReg).addImm(1);
MIB = BuildMI(*thisMBB, MI, DL, TII->get(PPC::EH_SjLj_Setup))
.addMBB(mainMBB);
MIB = BuildMI(*thisMBB, MI, DL, TII->get(PPC::B)).addMBB(sinkMBB);
thisMBB->addSuccessor(mainMBB, BranchProbability::getZero());
thisMBB->addSuccessor(sinkMBB, BranchProbability::getOne());
// mainMBB:
// mainDstReg = 0
MIB =
BuildMI(mainMBB, DL,
TII->get(Subtarget.isPPC64() ? PPC::MFLR8 : PPC::MFLR), LabelReg);
// Store IP
if (Subtarget.isPPC64()) {
MIB = BuildMI(mainMBB, DL, TII->get(PPC::STD))
.addReg(LabelReg)
.addImm(LabelOffset)
.addReg(BufReg);
} else {
MIB = BuildMI(mainMBB, DL, TII->get(PPC::STW))
.addReg(LabelReg)
.addImm(LabelOffset)
.addReg(BufReg);
}
MIB.cloneMemRefs(MI);
BuildMI(mainMBB, DL, TII->get(PPC::LI), mainDstReg).addImm(0);
mainMBB->addSuccessor(sinkMBB);
// sinkMBB:
BuildMI(*sinkMBB, sinkMBB->begin(), DL,
TII->get(PPC::PHI), DstReg)
.addReg(mainDstReg).addMBB(mainMBB)
.addReg(restoreDstReg).addMBB(thisMBB);
MI.eraseFromParent();
return sinkMBB;
}
MachineBasicBlock *
PPCTargetLowering::emitEHSjLjLongJmp(MachineInstr &MI,
MachineBasicBlock *MBB) const {
DebugLoc DL = MI.getDebugLoc();
const TargetInstrInfo *TII = Subtarget.getInstrInfo();
MachineFunction *MF = MBB->getParent();
MachineRegisterInfo &MRI = MF->getRegInfo();
MVT PVT = getPointerTy(MF->getDataLayout());
assert((PVT == MVT::i64 || PVT == MVT::i32) &&
"Invalid Pointer Size!");
const TargetRegisterClass *RC =
(PVT == MVT::i64) ? &PPC::G8RCRegClass : &PPC::GPRCRegClass;
Register Tmp = MRI.createVirtualRegister(RC);
// Since FP is only updated here but NOT referenced, it's treated as GPR.
unsigned FP = (PVT == MVT::i64) ? PPC::X31 : PPC::R31;
unsigned SP = (PVT == MVT::i64) ? PPC::X1 : PPC::R1;
unsigned BP =
(PVT == MVT::i64)
? PPC::X30
: (Subtarget.isSVR4ABI() && isPositionIndependent() ? PPC::R29
: PPC::R30);
MachineInstrBuilder MIB;
const int64_t LabelOffset = 1 * PVT.getStoreSize();
const int64_t SPOffset = 2 * PVT.getStoreSize();
const int64_t TOCOffset = 3 * PVT.getStoreSize();
const int64_t BPOffset = 4 * PVT.getStoreSize();
Register BufReg = MI.getOperand(0).getReg();
// Reload FP (the jumped-to function may not have had a
// frame pointer, and if so, then its r31 will be restored
// as necessary).
if (PVT == MVT::i64) {
MIB = BuildMI(*MBB, MI, DL, TII->get(PPC::LD), FP)
.addImm(0)
.addReg(BufReg);
} else {
MIB = BuildMI(*MBB, MI, DL, TII->get(PPC::LWZ), FP)
.addImm(0)
.addReg(BufReg);
}
MIB.cloneMemRefs(MI);
// Reload IP
if (PVT == MVT::i64) {
MIB = BuildMI(*MBB, MI, DL, TII->get(PPC::LD), Tmp)
.addImm(LabelOffset)
.addReg(BufReg);
} else {
MIB = BuildMI(*MBB, MI, DL, TII->get(PPC::LWZ), Tmp)
.addImm(LabelOffset)
.addReg(BufReg);
}
MIB.cloneMemRefs(MI);
// Reload SP
if (PVT == MVT::i64) {
MIB = BuildMI(*MBB, MI, DL, TII->get(PPC::LD), SP)
.addImm(SPOffset)
.addReg(BufReg);
} else {
MIB = BuildMI(*MBB, MI, DL, TII->get(PPC::LWZ), SP)
.addImm(SPOffset)
.addReg(BufReg);
}
MIB.cloneMemRefs(MI);
// Reload BP
if (PVT == MVT::i64) {
MIB = BuildMI(*MBB, MI, DL, TII->get(PPC::LD), BP)
.addImm(BPOffset)
.addReg(BufReg);
} else {
MIB = BuildMI(*MBB, MI, DL, TII->get(PPC::LWZ), BP)
.addImm(BPOffset)
.addReg(BufReg);
}
MIB.cloneMemRefs(MI);
// Reload TOC
if (PVT == MVT::i64 && Subtarget.isSVR4ABI()) {
setUsesTOCBasePtr(*MBB->getParent());
MIB = BuildMI(*MBB, MI, DL, TII->get(PPC::LD), PPC::X2)
.addImm(TOCOffset)
.addReg(BufReg)
.cloneMemRefs(MI);
}
// Jump
BuildMI(*MBB, MI, DL,
TII->get(PVT == MVT::i64 ? PPC::MTCTR8 : PPC::MTCTR)).addReg(Tmp);
BuildMI(*MBB, MI, DL, TII->get(PVT == MVT::i64 ? PPC::BCTR8 : PPC::BCTR));
MI.eraseFromParent();
return MBB;
}
bool PPCTargetLowering::hasInlineStackProbe(MachineFunction &MF) const {
// If the function specifically requests inline stack probes, emit them.
if (MF.getFunction().hasFnAttribute("probe-stack"))
return MF.getFunction().getFnAttribute("probe-stack").getValueAsString() ==
"inline-asm";
return false;
}
unsigned PPCTargetLowering::getStackProbeSize(MachineFunction &MF) const {
const TargetFrameLowering *TFI = Subtarget.getFrameLowering();
unsigned StackAlign = TFI->getStackAlignment();
assert(StackAlign >= 1 && isPowerOf2_32(StackAlign) &&
"Unexpected stack alignment");
// The default stack probe size is 4096 if the function has no
// stack-probe-size attribute.
unsigned StackProbeSize = 4096;
const Function &Fn = MF.getFunction();
if (Fn.hasFnAttribute("stack-probe-size"))
Fn.getFnAttribute("stack-probe-size")
.getValueAsString()
.getAsInteger(0, StackProbeSize);
// Round down to the stack alignment.
StackProbeSize &= ~(StackAlign - 1);
return StackProbeSize ? StackProbeSize : StackAlign;
}
// Lower dynamic stack allocation with probing. `emitProbedAlloca` is splitted
// into three phases. In the first phase, it uses pseudo instruction
// PREPARE_PROBED_ALLOCA to get the future result of actual FramePointer and
// FinalStackPtr. In the second phase, it generates a loop for probing blocks.
// At last, it uses pseudo instruction DYNAREAOFFSET to get the future result of
// MaxCallFrameSize so that it can calculate correct data area pointer.
MachineBasicBlock *
PPCTargetLowering::emitProbedAlloca(MachineInstr &MI,
MachineBasicBlock *MBB) const {
const bool isPPC64 = Subtarget.isPPC64();
MachineFunction *MF = MBB->getParent();
const TargetInstrInfo *TII = Subtarget.getInstrInfo();
DebugLoc DL = MI.getDebugLoc();
const unsigned ProbeSize = getStackProbeSize(*MF);
const BasicBlock *ProbedBB = MBB->getBasicBlock();
MachineRegisterInfo &MRI = MF->getRegInfo();
// The CFG of probing stack looks as
// +-----+
// | MBB |
// +--+--+
// |
// +----v----+
// +--->+ TestMBB +---+
// | +----+----+ |
// | | |
// | +-----v----+ |
// +---+ BlockMBB | |
// +----------+ |
// |
// +---------+ |
// | TailMBB +<--+
// +---------+
// In MBB, calculate previous frame pointer and final stack pointer.
// In TestMBB, test if sp is equal to final stack pointer, if so, jump to
// TailMBB. In BlockMBB, update the sp atomically and jump back to TestMBB.
// TailMBB is spliced via \p MI.
MachineBasicBlock *TestMBB = MF->CreateMachineBasicBlock(ProbedBB);
MachineBasicBlock *TailMBB = MF->CreateMachineBasicBlock(ProbedBB);
MachineBasicBlock *BlockMBB = MF->CreateMachineBasicBlock(ProbedBB);
MachineFunction::iterator MBBIter = ++MBB->getIterator();
MF->insert(MBBIter, TestMBB);
MF->insert(MBBIter, BlockMBB);
MF->insert(MBBIter, TailMBB);
const TargetRegisterClass *G8RC = &PPC::G8RCRegClass;
const TargetRegisterClass *GPRC = &PPC::GPRCRegClass;
Register DstReg = MI.getOperand(0).getReg();
Register NegSizeReg = MI.getOperand(1).getReg();
Register SPReg = isPPC64 ? PPC::X1 : PPC::R1;
Register FinalStackPtr = MRI.createVirtualRegister(isPPC64 ? G8RC : GPRC);
Register FramePointer = MRI.createVirtualRegister(isPPC64 ? G8RC : GPRC);
Register ActualNegSizeReg = MRI.createVirtualRegister(isPPC64 ? G8RC : GPRC);
// Since value of NegSizeReg might be realigned in prologepilog, insert a
// PREPARE_PROBED_ALLOCA pseudo instruction to get actual FramePointer and
// NegSize.
unsigned ProbeOpc;
if (!MRI.hasOneNonDBGUse(NegSizeReg))
ProbeOpc =
isPPC64 ? PPC::PREPARE_PROBED_ALLOCA_64 : PPC::PREPARE_PROBED_ALLOCA_32;
else
// By introducing PREPARE_PROBED_ALLOCA_NEGSIZE_OPT, ActualNegSizeReg
// and NegSizeReg will be allocated in the same phyreg to avoid
// redundant copy when NegSizeReg has only one use which is current MI and
// will be replaced by PREPARE_PROBED_ALLOCA then.
ProbeOpc = isPPC64 ? PPC::PREPARE_PROBED_ALLOCA_NEGSIZE_SAME_REG_64
: PPC::PREPARE_PROBED_ALLOCA_NEGSIZE_SAME_REG_32;
BuildMI(*MBB, {MI}, DL, TII->get(ProbeOpc), FramePointer)
.addDef(ActualNegSizeReg)
.addReg(NegSizeReg)
.add(MI.getOperand(2))
.add(MI.getOperand(3));
// Calculate final stack pointer, which equals to SP + ActualNegSize.
BuildMI(*MBB, {MI}, DL, TII->get(isPPC64 ? PPC::ADD8 : PPC::ADD4),
FinalStackPtr)
.addReg(SPReg)
.addReg(ActualNegSizeReg);
// Materialize a scratch register for update.
int64_t NegProbeSize = -(int64_t)ProbeSize;
assert(isInt<32>(NegProbeSize) && "Unhandled probe size!");
Register ScratchReg = MRI.createVirtualRegister(isPPC64 ? G8RC : GPRC);
if (!isInt<16>(NegProbeSize)) {
Register TempReg = MRI.createVirtualRegister(isPPC64 ? G8RC : GPRC);
BuildMI(*MBB, {MI}, DL, TII->get(isPPC64 ? PPC::LIS8 : PPC::LIS), TempReg)
.addImm(NegProbeSize >> 16);
BuildMI(*MBB, {MI}, DL, TII->get(isPPC64 ? PPC::ORI8 : PPC::ORI),
ScratchReg)
.addReg(TempReg)
.addImm(NegProbeSize & 0xFFFF);
} else
BuildMI(*MBB, {MI}, DL, TII->get(isPPC64 ? PPC::LI8 : PPC::LI), ScratchReg)
.addImm(NegProbeSize);
{
// Probing leading residual part.
Register Div = MRI.createVirtualRegister(isPPC64 ? G8RC : GPRC);
BuildMI(*MBB, {MI}, DL, TII->get(isPPC64 ? PPC::DIVD : PPC::DIVW), Div)
.addReg(ActualNegSizeReg)
.addReg(ScratchReg);
Register Mul = MRI.createVirtualRegister(isPPC64 ? G8RC : GPRC);
BuildMI(*MBB, {MI}, DL, TII->get(isPPC64 ? PPC::MULLD : PPC::MULLW), Mul)
.addReg(Div)
.addReg(ScratchReg);
Register NegMod = MRI.createVirtualRegister(isPPC64 ? G8RC : GPRC);
BuildMI(*MBB, {MI}, DL, TII->get(isPPC64 ? PPC::SUBF8 : PPC::SUBF), NegMod)
.addReg(Mul)
.addReg(ActualNegSizeReg);
BuildMI(*MBB, {MI}, DL, TII->get(isPPC64 ? PPC::STDUX : PPC::STWUX), SPReg)
.addReg(FramePointer)
.addReg(SPReg)
.addReg(NegMod);
}
{
// Remaining part should be multiple of ProbeSize.
Register CmpResult = MRI.createVirtualRegister(&PPC::CRRCRegClass);
BuildMI(TestMBB, DL, TII->get(isPPC64 ? PPC::CMPD : PPC::CMPW), CmpResult)
.addReg(SPReg)
.addReg(FinalStackPtr);
BuildMI(TestMBB, DL, TII->get(PPC::BCC))
.addImm(PPC::PRED_EQ)
.addReg(CmpResult)
.addMBB(TailMBB);
TestMBB->addSuccessor(BlockMBB);
TestMBB->addSuccessor(TailMBB);
}
{
// Touch the block.
// |P...|P...|P...
BuildMI(BlockMBB, DL, TII->get(isPPC64 ? PPC::STDUX : PPC::STWUX), SPReg)
.addReg(FramePointer)
.addReg(SPReg)
.addReg(ScratchReg);
BuildMI(BlockMBB, DL, TII->get(PPC::B)).addMBB(TestMBB);
BlockMBB->addSuccessor(TestMBB);
}
// Calculation of MaxCallFrameSize is deferred to prologepilog, use
// DYNAREAOFFSET pseudo instruction to get the future result.
Register MaxCallFrameSizeReg =
MRI.createVirtualRegister(isPPC64 ? G8RC : GPRC);
BuildMI(TailMBB, DL,
TII->get(isPPC64 ? PPC::DYNAREAOFFSET8 : PPC::DYNAREAOFFSET),
MaxCallFrameSizeReg)
.add(MI.getOperand(2))
.add(MI.getOperand(3));
BuildMI(TailMBB, DL, TII->get(isPPC64 ? PPC::ADD8 : PPC::ADD4), DstReg)
.addReg(SPReg)
.addReg(MaxCallFrameSizeReg);
// Splice instructions after MI to TailMBB.
TailMBB->splice(TailMBB->end(), MBB,
std::next(MachineBasicBlock::iterator(MI)), MBB->end());
TailMBB->transferSuccessorsAndUpdatePHIs(MBB);
MBB->addSuccessor(TestMBB);
// Delete the pseudo instruction.
MI.eraseFromParent();
++NumDynamicAllocaProbed;
return TailMBB;
}
MachineBasicBlock *
PPCTargetLowering::EmitInstrWithCustomInserter(MachineInstr &MI,
MachineBasicBlock *BB) const {
if (MI.getOpcode() == TargetOpcode::STACKMAP ||
MI.getOpcode() == TargetOpcode::PATCHPOINT) {
if (Subtarget.is64BitELFABI() &&
MI.getOpcode() == TargetOpcode::PATCHPOINT &&
!Subtarget.isUsingPCRelativeCalls()) {
// Call lowering should have added an r2 operand to indicate a dependence
// on the TOC base pointer value. It can't however, because there is no
// way to mark the dependence as implicit there, and so the stackmap code
// will confuse it with a regular operand. Instead, add the dependence
// here.
MI.addOperand(MachineOperand::CreateReg(PPC::X2, false, true));
}
return emitPatchPoint(MI, BB);
}
if (MI.getOpcode() == PPC::EH_SjLj_SetJmp32 ||
MI.getOpcode() == PPC::EH_SjLj_SetJmp64) {
return emitEHSjLjSetJmp(MI, BB);
} else if (MI.getOpcode() == PPC::EH_SjLj_LongJmp32 ||
MI.getOpcode() == PPC::EH_SjLj_LongJmp64) {
return emitEHSjLjLongJmp(MI, BB);
}
const TargetInstrInfo *TII = Subtarget.getInstrInfo();
// To "insert" these instructions we actually have to insert their
// control-flow patterns.
const BasicBlock *LLVM_BB = BB->getBasicBlock();
MachineFunction::iterator It = ++BB->getIterator();
MachineFunction *F = BB->getParent();
MachineRegisterInfo &MRI = F->getRegInfo();
if (MI.getOpcode() == PPC::SELECT_CC_I4 ||
MI.getOpcode() == PPC::SELECT_CC_I8 || MI.getOpcode() == PPC::SELECT_I4 ||
MI.getOpcode() == PPC::SELECT_I8) {
SmallVector<MachineOperand, 2> Cond;
if (MI.getOpcode() == PPC::SELECT_CC_I4 ||
MI.getOpcode() == PPC::SELECT_CC_I8)
Cond.push_back(MI.getOperand(4));
else
Cond.push_back(MachineOperand::CreateImm(PPC::PRED_BIT_SET));
Cond.push_back(MI.getOperand(1));
DebugLoc dl = MI.getDebugLoc();
TII->insertSelect(*BB, MI, dl, MI.getOperand(0).getReg(), Cond,
MI.getOperand(2).getReg(), MI.getOperand(3).getReg());
} else if (MI.getOpcode() == PPC::SELECT_CC_F4 ||
MI.getOpcode() == PPC::SELECT_CC_F8 ||
MI.getOpcode() == PPC::SELECT_CC_F16 ||
MI.getOpcode() == PPC::SELECT_CC_VRRC ||
MI.getOpcode() == PPC::SELECT_CC_VSFRC ||
MI.getOpcode() == PPC::SELECT_CC_VSSRC ||
MI.getOpcode() == PPC::SELECT_CC_VSRC ||
MI.getOpcode() == PPC::SELECT_CC_SPE4 ||
MI.getOpcode() == PPC::SELECT_CC_SPE ||
MI.getOpcode() == PPC::SELECT_F4 ||
MI.getOpcode() == PPC::SELECT_F8 ||
MI.getOpcode() == PPC::SELECT_F16 ||
MI.getOpcode() == PPC::SELECT_SPE ||
MI.getOpcode() == PPC::SELECT_SPE4 ||
MI.getOpcode() == PPC::SELECT_VRRC ||
MI.getOpcode() == PPC::SELECT_VSFRC ||
MI.getOpcode() == PPC::SELECT_VSSRC ||
MI.getOpcode() == PPC::SELECT_VSRC) {
// The incoming instruction knows the destination vreg to set, the
// condition code register to branch on, the true/false values to
// select between, and a branch opcode to use.
// thisMBB:
// ...
// TrueVal = ...
// cmpTY ccX, r1, r2
// bCC copy1MBB
// fallthrough --> copy0MBB
MachineBasicBlock *thisMBB = BB;
MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
DebugLoc dl = MI.getDebugLoc();
F->insert(It, copy0MBB);
F->insert(It, sinkMBB);
// Transfer the remainder of BB and its successor edges to sinkMBB.
sinkMBB->splice(sinkMBB->begin(), BB,
std::next(MachineBasicBlock::iterator(MI)), BB->end());
sinkMBB->transferSuccessorsAndUpdatePHIs(BB);
// Next, add the true and fallthrough blocks as its successors.
BB->addSuccessor(copy0MBB);
BB->addSuccessor(sinkMBB);
if (MI.getOpcode() == PPC::SELECT_I4 || MI.getOpcode() == PPC::SELECT_I8 ||
MI.getOpcode() == PPC::SELECT_F4 || MI.getOpcode() == PPC::SELECT_F8 ||
MI.getOpcode() == PPC::SELECT_F16 ||
MI.getOpcode() == PPC::SELECT_SPE4 ||
MI.getOpcode() == PPC::SELECT_SPE ||
MI.getOpcode() == PPC::SELECT_VRRC ||
MI.getOpcode() == PPC::SELECT_VSFRC ||
MI.getOpcode() == PPC::SELECT_VSSRC ||
MI.getOpcode() == PPC::SELECT_VSRC) {
BuildMI(BB, dl, TII->get(PPC::BC))
.addReg(MI.getOperand(1).getReg())
.addMBB(sinkMBB);
} else {
unsigned SelectPred = MI.getOperand(4).getImm();
BuildMI(BB, dl, TII->get(PPC::BCC))
.addImm(SelectPred)
.addReg(MI.getOperand(1).getReg())
.addMBB(sinkMBB);
}
// copy0MBB:
// %FalseValue = ...
// # fallthrough to sinkMBB
BB = copy0MBB;
// Update machine-CFG edges
BB->addSuccessor(sinkMBB);
// sinkMBB:
// %Result = phi [ %FalseValue, copy0MBB ], [ %TrueValue, thisMBB ]
// ...
BB = sinkMBB;
BuildMI(*BB, BB->begin(), dl, TII->get(PPC::PHI), MI.getOperand(0).getReg())
.addReg(MI.getOperand(3).getReg())
.addMBB(copy0MBB)
.addReg(MI.getOperand(2).getReg())
.addMBB(thisMBB);
} else if (MI.getOpcode() == PPC::ReadTB) {
// To read the 64-bit time-base register on a 32-bit target, we read the
// two halves. Should the counter have wrapped while it was being read, we
// need to try again.
// ...
// readLoop:
// mfspr Rx,TBU # load from TBU
// mfspr Ry,TB # load from TB
// mfspr Rz,TBU # load from TBU
// cmpw crX,Rx,Rz # check if 'old'='new'
// bne readLoop # branch if they're not equal
// ...
MachineBasicBlock *readMBB = F->CreateMachineBasicBlock(LLVM_BB);
MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
DebugLoc dl = MI.getDebugLoc();
F->insert(It, readMBB);
F->insert(It, sinkMBB);
// Transfer the remainder of BB and its successor edges to sinkMBB.
sinkMBB->splice(sinkMBB->begin(), BB,
std::next(MachineBasicBlock::iterator(MI)), BB->end());
sinkMBB->transferSuccessorsAndUpdatePHIs(BB);
BB->addSuccessor(readMBB);
BB = readMBB;
MachineRegisterInfo &RegInfo = F->getRegInfo();
Register ReadAgainReg = RegInfo.createVirtualRegister(&PPC::GPRCRegClass);
Register LoReg = MI.getOperand(0).getReg();
Register HiReg = MI.getOperand(1).getReg();
BuildMI(BB, dl, TII->get(PPC::MFSPR), HiReg).addImm(269);
BuildMI(BB, dl, TII->get(PPC::MFSPR), LoReg).addImm(268);
BuildMI(BB, dl, TII->get(PPC::MFSPR), ReadAgainReg).addImm(269);
Register CmpReg = RegInfo.createVirtualRegister(&PPC::CRRCRegClass);
BuildMI(BB, dl, TII->get(PPC::CMPW), CmpReg)
.addReg(HiReg)
.addReg(ReadAgainReg);
BuildMI(BB, dl, TII->get(PPC::BCC))
.addImm(PPC::PRED_NE)
.addReg(CmpReg)
.addMBB(readMBB);
BB->addSuccessor(readMBB);
BB->addSuccessor(sinkMBB);
} else if (MI.getOpcode() == PPC::ATOMIC_LOAD_ADD_I8)
BB = EmitPartwordAtomicBinary(MI, BB, true, PPC::ADD4);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_ADD_I16)
BB = EmitPartwordAtomicBinary(MI, BB, false, PPC::ADD4);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_ADD_I32)
BB = EmitAtomicBinary(MI, BB, 4, PPC::ADD4);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_ADD_I64)
BB = EmitAtomicBinary(MI, BB, 8, PPC::ADD8);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_AND_I8)
BB = EmitPartwordAtomicBinary(MI, BB, true, PPC::AND);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_AND_I16)
BB = EmitPartwordAtomicBinary(MI, BB, false, PPC::AND);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_AND_I32)
BB = EmitAtomicBinary(MI, BB, 4, PPC::AND);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_AND_I64)
BB = EmitAtomicBinary(MI, BB, 8, PPC::AND8);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_OR_I8)
BB = EmitPartwordAtomicBinary(MI, BB, true, PPC::OR);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_OR_I16)
BB = EmitPartwordAtomicBinary(MI, BB, false, PPC::OR);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_OR_I32)
BB = EmitAtomicBinary(MI, BB, 4, PPC::OR);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_OR_I64)
BB = EmitAtomicBinary(MI, BB, 8, PPC::OR8);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_XOR_I8)
BB = EmitPartwordAtomicBinary(MI, BB, true, PPC::XOR);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_XOR_I16)
BB = EmitPartwordAtomicBinary(MI, BB, false, PPC::XOR);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_XOR_I32)
BB = EmitAtomicBinary(MI, BB, 4, PPC::XOR);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_XOR_I64)
BB = EmitAtomicBinary(MI, BB, 8, PPC::XOR8);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_NAND_I8)
BB = EmitPartwordAtomicBinary(MI, BB, true, PPC::NAND);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_NAND_I16)
BB = EmitPartwordAtomicBinary(MI, BB, false, PPC::NAND);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_NAND_I32)
BB = EmitAtomicBinary(MI, BB, 4, PPC::NAND);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_NAND_I64)
BB = EmitAtomicBinary(MI, BB, 8, PPC::NAND8);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_SUB_I8)
BB = EmitPartwordAtomicBinary(MI, BB, true, PPC::SUBF);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_SUB_I16)
BB = EmitPartwordAtomicBinary(MI, BB, false, PPC::SUBF);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_SUB_I32)
BB = EmitAtomicBinary(MI, BB, 4, PPC::SUBF);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_SUB_I64)
BB = EmitAtomicBinary(MI, BB, 8, PPC::SUBF8);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_MIN_I8)
BB = EmitPartwordAtomicBinary(MI, BB, true, 0, PPC::CMPW, PPC::PRED_GE);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_MIN_I16)
BB = EmitPartwordAtomicBinary(MI, BB, false, 0, PPC::CMPW, PPC::PRED_GE);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_MIN_I32)
BB = EmitAtomicBinary(MI, BB, 4, 0, PPC::CMPW, PPC::PRED_GE);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_MIN_I64)
BB = EmitAtomicBinary(MI, BB, 8, 0, PPC::CMPD, PPC::PRED_GE);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_MAX_I8)
BB = EmitPartwordAtomicBinary(MI, BB, true, 0, PPC::CMPW, PPC::PRED_LE);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_MAX_I16)
BB = EmitPartwordAtomicBinary(MI, BB, false, 0, PPC::CMPW, PPC::PRED_LE);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_MAX_I32)
BB = EmitAtomicBinary(MI, BB, 4, 0, PPC::CMPW, PPC::PRED_LE);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_MAX_I64)
BB = EmitAtomicBinary(MI, BB, 8, 0, PPC::CMPD, PPC::PRED_LE);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_UMIN_I8)
BB = EmitPartwordAtomicBinary(MI, BB, true, 0, PPC::CMPLW, PPC::PRED_GE);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_UMIN_I16)
BB = EmitPartwordAtomicBinary(MI, BB, false, 0, PPC::CMPLW, PPC::PRED_GE);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_UMIN_I32)
BB = EmitAtomicBinary(MI, BB, 4, 0, PPC::CMPLW, PPC::PRED_GE);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_UMIN_I64)
BB = EmitAtomicBinary(MI, BB, 8, 0, PPC::CMPLD, PPC::PRED_GE);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_UMAX_I8)
BB = EmitPartwordAtomicBinary(MI, BB, true, 0, PPC::CMPLW, PPC::PRED_LE);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_UMAX_I16)
BB = EmitPartwordAtomicBinary(MI, BB, false, 0, PPC::CMPLW, PPC::PRED_LE);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_UMAX_I32)
BB = EmitAtomicBinary(MI, BB, 4, 0, PPC::CMPLW, PPC::PRED_LE);
else if (MI.getOpcode() == PPC::ATOMIC_LOAD_UMAX_I64)
BB = EmitAtomicBinary(MI, BB, 8, 0, PPC::CMPLD, PPC::PRED_LE);
else if (MI.getOpcode() == PPC::ATOMIC_SWAP_I8)
BB = EmitPartwordAtomicBinary(MI, BB, true, 0);
else if (MI.getOpcode() == PPC::ATOMIC_SWAP_I16)
BB = EmitPartwordAtomicBinary(MI, BB, false, 0);
else if (MI.getOpcode() == PPC::ATOMIC_SWAP_I32)
BB = EmitAtomicBinary(MI, BB, 4, 0);
else if (MI.getOpcode() == PPC::ATOMIC_SWAP_I64)
BB = EmitAtomicBinary(MI, BB, 8, 0);
else if (MI.getOpcode() == PPC::ATOMIC_CMP_SWAP_I32 ||
MI.getOpcode() == PPC::ATOMIC_CMP_SWAP_I64 ||
(Subtarget.hasPartwordAtomics() &&
MI.getOpcode() == PPC::ATOMIC_CMP_SWAP_I8) ||
(Subtarget.hasPartwordAtomics() &&
MI.getOpcode() == PPC::ATOMIC_CMP_SWAP_I16)) {
bool is64bit = MI.getOpcode() == PPC::ATOMIC_CMP_SWAP_I64;
auto LoadMnemonic = PPC::LDARX;
auto StoreMnemonic = PPC::STDCX;
switch (MI.getOpcode()) {
default:
llvm_unreachable("Compare and swap of unknown size");
case PPC::ATOMIC_CMP_SWAP_I8:
LoadMnemonic = PPC::LBARX;
StoreMnemonic = PPC::STBCX;
assert(Subtarget.hasPartwordAtomics() && "No support partword atomics.");
break;
case PPC::ATOMIC_CMP_SWAP_I16:
LoadMnemonic = PPC::LHARX;
StoreMnemonic = PPC::STHCX;
assert(Subtarget.hasPartwordAtomics() && "No support partword atomics.");
break;
case PPC::ATOMIC_CMP_SWAP_I32:
LoadMnemonic = PPC::LWARX;
StoreMnemonic = PPC::STWCX;
break;
case PPC::ATOMIC_CMP_SWAP_I64:
LoadMnemonic = PPC::LDARX;
StoreMnemonic = PPC::STDCX;
break;
}
Register dest = MI.getOperand(0).getReg();
Register ptrA = MI.getOperand(1).getReg();
Register ptrB = MI.getOperand(2).getReg();
Register oldval = MI.getOperand(3).getReg();
Register newval = MI.getOperand(4).getReg();
DebugLoc dl = MI.getDebugLoc();
MachineBasicBlock *loop1MBB = F->CreateMachineBasicBlock(LLVM_BB);
MachineBasicBlock *loop2MBB = F->CreateMachineBasicBlock(LLVM_BB);
MachineBasicBlock *midMBB = F->CreateMachineBasicBlock(LLVM_BB);
MachineBasicBlock *exitMBB = F->CreateMachineBasicBlock(LLVM_BB);
F->insert(It, loop1MBB);
F->insert(It, loop2MBB);
F->insert(It, midMBB);
F->insert(It, exitMBB);
exitMBB->splice(exitMBB->begin(), BB,
std::next(MachineBasicBlock::iterator(MI)), BB->end());
exitMBB->transferSuccessorsAndUpdatePHIs(BB);
// thisMBB:
// ...
// fallthrough --> loopMBB
BB->addSuccessor(loop1MBB);
// loop1MBB:
// l[bhwd]arx dest, ptr
// cmp[wd] dest, oldval
// bne- midMBB
// loop2MBB:
// st[bhwd]cx. newval, ptr
// bne- loopMBB
// b exitBB
// midMBB:
// st[bhwd]cx. dest, ptr
// exitBB:
BB = loop1MBB;
BuildMI(BB, dl, TII->get(LoadMnemonic), dest).addReg(ptrA).addReg(ptrB);
BuildMI(BB, dl, TII->get(is64bit ? PPC::CMPD : PPC::CMPW), PPC::CR0)
.addReg(oldval)
.addReg(dest);
BuildMI(BB, dl, TII->get(PPC::BCC))
.addImm(PPC::PRED_NE)
.addReg(PPC::CR0)
.addMBB(midMBB);
BB->addSuccessor(loop2MBB);
BB->addSuccessor(midMBB);
BB = loop2MBB;
BuildMI(BB, dl, TII->get(StoreMnemonic))
.addReg(newval)
.addReg(ptrA)
.addReg(ptrB);
BuildMI(BB, dl, TII->get(PPC::BCC))
.addImm(PPC::PRED_NE)
.addReg(PPC::CR0)
.addMBB(loop1MBB);
BuildMI(BB, dl, TII->get(PPC::B)).addMBB(exitMBB);
BB->addSuccessor(loop1MBB);
BB->addSuccessor(exitMBB);
BB = midMBB;
BuildMI(BB, dl, TII->get(StoreMnemonic))
.addReg(dest)
.addReg(ptrA)
.addReg(ptrB);
BB->addSuccessor(exitMBB);
// exitMBB:
// ...
BB = exitMBB;
} else if (MI.getOpcode() == PPC::ATOMIC_CMP_SWAP_I8 ||
MI.getOpcode() == PPC::ATOMIC_CMP_SWAP_I16) {
// We must use 64-bit registers for addresses when targeting 64-bit,
// since we're actually doing arithmetic on them. Other registers
// can be 32-bit.
bool is64bit = Subtarget.isPPC64();
bool isLittleEndian = Subtarget.isLittleEndian();
bool is8bit = MI.getOpcode() == PPC::ATOMIC_CMP_SWAP_I8;
Register dest = MI.getOperand(0).getReg();
Register ptrA = MI.getOperand(1).getReg();
Register ptrB = MI.getOperand(2).getReg();
Register oldval = MI.getOperand(3).getReg();
Register newval = MI.getOperand(4).getReg();
DebugLoc dl = MI.getDebugLoc();
MachineBasicBlock *loop1MBB = F->CreateMachineBasicBlock(LLVM_BB);
MachineBasicBlock *loop2MBB = F->CreateMachineBasicBlock(LLVM_BB);
MachineBasicBlock *midMBB = F->CreateMachineBasicBlock(LLVM_BB);
MachineBasicBlock *exitMBB = F->CreateMachineBasicBlock(LLVM_BB);
F->insert(It, loop1MBB);
F->insert(It, loop2MBB);
F->insert(It, midMBB);
F->insert(It, exitMBB);
exitMBB->splice(exitMBB->begin(), BB,
std::next(MachineBasicBlock::iterator(MI)), BB->end());
exitMBB->transferSuccessorsAndUpdatePHIs(BB);
MachineRegisterInfo &RegInfo = F->getRegInfo();
const TargetRegisterClass *RC =
is64bit ? &PPC::G8RCRegClass : &PPC::GPRCRegClass;
const TargetRegisterClass *GPRC = &PPC::GPRCRegClass;
Register PtrReg = RegInfo.createVirtualRegister(RC);
Register Shift1Reg = RegInfo.createVirtualRegister(GPRC);
Register ShiftReg =
isLittleEndian ? Shift1Reg : RegInfo.createVirtualRegister(GPRC);
Register NewVal2Reg = RegInfo.createVirtualRegister(GPRC);
Register NewVal3Reg = RegInfo.createVirtualRegister(GPRC);
Register OldVal2Reg = RegInfo.createVirtualRegister(GPRC);
Register OldVal3Reg = RegInfo.createVirtualRegister(GPRC);
Register MaskReg = RegInfo.createVirtualRegister(GPRC);
Register Mask2Reg = RegInfo.createVirtualRegister(GPRC);
Register Mask3Reg = RegInfo.createVirtualRegister(GPRC);
Register Tmp2Reg = RegInfo.createVirtualRegister(GPRC);
Register Tmp4Reg = RegInfo.createVirtualRegister(GPRC);
Register TmpDestReg = RegInfo.createVirtualRegister(GPRC);
Register Ptr1Reg;
Register TmpReg = RegInfo.createVirtualRegister(GPRC);
Register ZeroReg = is64bit ? PPC::ZERO8 : PPC::ZERO;
// thisMBB:
// ...
// fallthrough --> loopMBB
BB->addSuccessor(loop1MBB);
// The 4-byte load must be aligned, while a char or short may be
// anywhere in the word. Hence all this nasty bookkeeping code.
// add ptr1, ptrA, ptrB [copy if ptrA==0]
// rlwinm shift1, ptr1, 3, 27, 28 [3, 27, 27]
// xori shift, shift1, 24 [16]
// rlwinm ptr, ptr1, 0, 0, 29
// slw newval2, newval, shift
// slw oldval2, oldval,shift
// li mask2, 255 [li mask3, 0; ori mask2, mask3, 65535]
// slw mask, mask2, shift
// and newval3, newval2, mask
// and oldval3, oldval2, mask
// loop1MBB:
// lwarx tmpDest, ptr
// and tmp, tmpDest, mask
// cmpw tmp, oldval3
// bne- midMBB
// loop2MBB:
// andc tmp2, tmpDest, mask
// or tmp4, tmp2, newval3
// stwcx. tmp4, ptr
// bne- loop1MBB
// b exitBB
// midMBB:
// stwcx. tmpDest, ptr
// exitBB:
// srw dest, tmpDest, shift
if (ptrA != ZeroReg) {
Ptr1Reg = RegInfo.createVirtualRegister(RC);
BuildMI(BB, dl, TII->get(is64bit ? PPC::ADD8 : PPC::ADD4), Ptr1Reg)
.addReg(ptrA)
.addReg(ptrB);
} else {
Ptr1Reg = ptrB;
}
// We need use 32-bit subregister to avoid mismatch register class in 64-bit
// mode.
BuildMI(BB, dl, TII->get(PPC::RLWINM), Shift1Reg)
.addReg(Ptr1Reg, 0, is64bit ? PPC::sub_32 : 0)
.addImm(3)
.addImm(27)
.addImm(is8bit ? 28 : 27);
if (!isLittleEndian)
BuildMI(BB, dl, TII->get(PPC::XORI), ShiftReg)
.addReg(Shift1Reg)
.addImm(is8bit ? 24 : 16);
if (is64bit)
BuildMI(BB, dl, TII->get(PPC::RLDICR), PtrReg)
.addReg(Ptr1Reg)
.addImm(0)
.addImm(61);
else
BuildMI(BB, dl, TII->get(PPC::RLWINM), PtrReg)
.addReg(Ptr1Reg)
.addImm(0)
.addImm(0)
.addImm(29);
BuildMI(BB, dl, TII->get(PPC::SLW), NewVal2Reg)
.addReg(newval)
.addReg(ShiftReg);
BuildMI(BB, dl, TII->get(PPC::SLW), OldVal2Reg)
.addReg(oldval)
.addReg(ShiftReg);
if (is8bit)
BuildMI(BB, dl, TII->get(PPC::LI), Mask2Reg).addImm(255);
else {
BuildMI(BB, dl, TII->get(PPC::LI), Mask3Reg).addImm(0);
BuildMI(BB, dl, TII->get(PPC::ORI), Mask2Reg)
.addReg(Mask3Reg)
.addImm(65535);
}
BuildMI(BB, dl, TII->get(PPC::SLW), MaskReg)
.addReg(Mask2Reg)
.addReg(ShiftReg);
BuildMI(BB, dl, TII->get(PPC::AND), NewVal3Reg)
.addReg(NewVal2Reg)
.addReg(MaskReg);
BuildMI(BB, dl, TII->get(PPC::AND), OldVal3Reg)
.addReg(OldVal2Reg)
.addReg(MaskReg);
BB = loop1MBB;
BuildMI(BB, dl, TII->get(PPC::LWARX), TmpDestReg)
.addReg(ZeroReg)
.addReg(PtrReg);
BuildMI(BB, dl, TII->get(PPC::AND), TmpReg)
.addReg(TmpDestReg)
.addReg(MaskReg);
BuildMI(BB, dl, TII->get(PPC::CMPW), PPC::CR0)
.addReg(TmpReg)
.addReg(OldVal3Reg);
BuildMI(BB, dl, TII->get(PPC::BCC))
.addImm(PPC::PRED_NE)
.addReg(PPC::CR0)
.addMBB(midMBB);
BB->addSuccessor(loop2MBB);
BB->addSuccessor(midMBB);
BB = loop2MBB;
BuildMI(BB, dl, TII->get(PPC::ANDC), Tmp2Reg)
.addReg(TmpDestReg)
.addReg(MaskReg);
BuildMI(BB, dl, TII->get(PPC::OR), Tmp4Reg)
.addReg(Tmp2Reg)
.addReg(NewVal3Reg);
BuildMI(BB, dl, TII->get(PPC::STWCX))
.addReg(Tmp4Reg)
.addReg(ZeroReg)
.addReg(PtrReg);
BuildMI(BB, dl, TII->get(PPC::BCC))
.addImm(PPC::PRED_NE)
.addReg(PPC::CR0)
.addMBB(loop1MBB);
BuildMI(BB, dl, TII->get(PPC::B)).addMBB(exitMBB);
BB->addSuccessor(loop1MBB);
BB->addSuccessor(exitMBB);
BB = midMBB;
BuildMI(BB, dl, TII->get(PPC::STWCX))
.addReg(TmpDestReg)
.addReg(ZeroReg)
.addReg(PtrReg);
BB->addSuccessor(exitMBB);
// exitMBB:
// ...
BB = exitMBB;
BuildMI(*BB, BB->begin(), dl, TII->get(PPC::SRW), dest)
.addReg(TmpReg)
.addReg(ShiftReg);
} else if (MI.getOpcode() == PPC::FADDrtz) {
// This pseudo performs an FADD with rounding mode temporarily forced
// to round-to-zero. We emit this via custom inserter since the FPSCR
// is not modeled at the SelectionDAG level.
Register Dest = MI.getOperand(0).getReg();
Register Src1 = MI.getOperand(1).getReg();
Register Src2 = MI.getOperand(2).getReg();
DebugLoc dl = MI.getDebugLoc();
MachineRegisterInfo &RegInfo = F->getRegInfo();
Register MFFSReg = RegInfo.createVirtualRegister(&PPC::F8RCRegClass);
// Save FPSCR value.
BuildMI(*BB, MI, dl, TII->get(PPC::MFFS), MFFSReg);
// Set rounding mode to round-to-zero.
BuildMI(*BB, MI, dl, TII->get(PPC::MTFSB1))
.addImm(31)
.addReg(PPC::RM, RegState::ImplicitDefine);
BuildMI(*BB, MI, dl, TII->get(PPC::MTFSB0))
.addImm(30)
.addReg(PPC::RM, RegState::ImplicitDefine);
// Perform addition.
auto MIB = BuildMI(*BB, MI, dl, TII->get(PPC::FADD), Dest)
.addReg(Src1)
.addReg(Src2);
if (MI.getFlag(MachineInstr::NoFPExcept))
MIB.setMIFlag(MachineInstr::NoFPExcept);
// Restore FPSCR value.
BuildMI(*BB, MI, dl, TII->get(PPC::MTFSFb)).addImm(1).addReg(MFFSReg);
} else if (MI.getOpcode() == PPC::ANDI_rec_1_EQ_BIT ||
MI.getOpcode() == PPC::ANDI_rec_1_GT_BIT ||
MI.getOpcode() == PPC::ANDI_rec_1_EQ_BIT8 ||
MI.getOpcode() == PPC::ANDI_rec_1_GT_BIT8) {
unsigned Opcode = (MI.getOpcode() == PPC::ANDI_rec_1_EQ_BIT8 ||
MI.getOpcode() == PPC::ANDI_rec_1_GT_BIT8)
? PPC::ANDI8_rec
: PPC::ANDI_rec;
bool IsEQ = (MI.getOpcode() == PPC::ANDI_rec_1_EQ_BIT ||
MI.getOpcode() == PPC::ANDI_rec_1_EQ_BIT8);
MachineRegisterInfo &RegInfo = F->getRegInfo();
Register Dest = RegInfo.createVirtualRegister(
Opcode == PPC::ANDI_rec ? &PPC::GPRCRegClass : &PPC::G8RCRegClass);
DebugLoc Dl = MI.getDebugLoc();
BuildMI(*BB, MI, Dl, TII->get(Opcode), Dest)
.addReg(MI.getOperand(1).getReg())
.addImm(1);
BuildMI(*BB, MI, Dl, TII->get(TargetOpcode::COPY),
MI.getOperand(0).getReg())
.addReg(IsEQ ? PPC::CR0EQ : PPC::CR0GT);
} else if (MI.getOpcode() == PPC::TCHECK_RET) {
DebugLoc Dl = MI.getDebugLoc();
MachineRegisterInfo &RegInfo = F->getRegInfo();
Register CRReg = RegInfo.createVirtualRegister(&PPC::CRRCRegClass);
BuildMI(*BB, MI, Dl, TII->get(PPC::TCHECK), CRReg);
BuildMI(*BB, MI, Dl, TII->get(TargetOpcode::COPY),
MI.getOperand(0).getReg())
.addReg(CRReg);
} else if (MI.getOpcode() == PPC::TBEGIN_RET) {
DebugLoc Dl = MI.getDebugLoc();
unsigned Imm = MI.getOperand(1).getImm();
BuildMI(*BB, MI, Dl, TII->get(PPC::TBEGIN)).addImm(Imm);
BuildMI(*BB, MI, Dl, TII->get(TargetOpcode::COPY),
MI.getOperand(0).getReg())
.addReg(PPC::CR0EQ);
} else if (MI.getOpcode() == PPC::SETRNDi) {
DebugLoc dl = MI.getDebugLoc();
Register OldFPSCRReg = MI.getOperand(0).getReg();
// Save FPSCR value.
if (MRI.use_empty(OldFPSCRReg))
BuildMI(*BB, MI, dl, TII->get(TargetOpcode::IMPLICIT_DEF), OldFPSCRReg);
else
BuildMI(*BB, MI, dl, TII->get(PPC::MFFS), OldFPSCRReg);
// The floating point rounding mode is in the bits 62:63 of FPCSR, and has
// the following settings:
// 00 Round to nearest
// 01 Round to 0
// 10 Round to +inf
// 11 Round to -inf
// When the operand is immediate, using the two least significant bits of
// the immediate to set the bits 62:63 of FPSCR.
unsigned Mode = MI.getOperand(1).getImm();
BuildMI(*BB, MI, dl, TII->get((Mode & 1) ? PPC::MTFSB1 : PPC::MTFSB0))
.addImm(31)
.addReg(PPC::RM, RegState::ImplicitDefine);
BuildMI(*BB, MI, dl, TII->get((Mode & 2) ? PPC::MTFSB1 : PPC::MTFSB0))
.addImm(30)
.addReg(PPC::RM, RegState::ImplicitDefine);
} else if (MI.getOpcode() == PPC::SETRND) {
DebugLoc dl = MI.getDebugLoc();
// Copy register from F8RCRegClass::SrcReg to G8RCRegClass::DestReg
// or copy register from G8RCRegClass::SrcReg to F8RCRegClass::DestReg.
// If the target doesn't have DirectMove, we should use stack to do the
// conversion, because the target doesn't have the instructions like mtvsrd
// or mfvsrd to do this conversion directly.
auto copyRegFromG8RCOrF8RC = [&] (unsigned DestReg, unsigned SrcReg) {
if (Subtarget.hasDirectMove()) {
BuildMI(*BB, MI, dl, TII->get(TargetOpcode::COPY), DestReg)
.addReg(SrcReg);
} else {
// Use stack to do the register copy.
unsigned StoreOp = PPC::STD, LoadOp = PPC::LFD;
MachineRegisterInfo &RegInfo = F->getRegInfo();
const TargetRegisterClass *RC = RegInfo.getRegClass(SrcReg);
if (RC == &PPC::F8RCRegClass) {
// Copy register from F8RCRegClass to G8RCRegclass.
assert((RegInfo.getRegClass(DestReg) == &PPC::G8RCRegClass) &&
"Unsupported RegClass.");
StoreOp = PPC::STFD;
LoadOp = PPC::LD;
} else {
// Copy register from G8RCRegClass to F8RCRegclass.
assert((RegInfo.getRegClass(SrcReg) == &PPC::G8RCRegClass) &&
(RegInfo.getRegClass(DestReg) == &PPC::F8RCRegClass) &&
"Unsupported RegClass.");
}
MachineFrameInfo &MFI = F->getFrameInfo();
int FrameIdx = MFI.CreateStackObject(8, Align(8), false);
MachineMemOperand *MMOStore = F->getMachineMemOperand(
MachinePointerInfo::getFixedStack(*F, FrameIdx, 0),
MachineMemOperand::MOStore, MFI.getObjectSize(FrameIdx),
MFI.getObjectAlign(FrameIdx));
// Store the SrcReg into the stack.
BuildMI(*BB, MI, dl, TII->get(StoreOp))
.addReg(SrcReg)
.addImm(0)
.addFrameIndex(FrameIdx)
.addMemOperand(MMOStore);
MachineMemOperand *MMOLoad = F->getMachineMemOperand(
MachinePointerInfo::getFixedStack(*F, FrameIdx, 0),
MachineMemOperand::MOLoad, MFI.getObjectSize(FrameIdx),
MFI.getObjectAlign(FrameIdx));
// Load from the stack where SrcReg is stored, and save to DestReg,
// so we have done the RegClass conversion from RegClass::SrcReg to
// RegClass::DestReg.
BuildMI(*BB, MI, dl, TII->get(LoadOp), DestReg)
.addImm(0)
.addFrameIndex(FrameIdx)
.addMemOperand(MMOLoad);
}
};
Register OldFPSCRReg = MI.getOperand(0).getReg();
// Save FPSCR value.
BuildMI(*BB, MI, dl, TII->get(PPC::MFFS), OldFPSCRReg);
// When the operand is gprc register, use two least significant bits of the
// register and mtfsf instruction to set the bits 62:63 of FPSCR.
//
// copy OldFPSCRTmpReg, OldFPSCRReg
// (INSERT_SUBREG ExtSrcReg, (IMPLICIT_DEF ImDefReg), SrcOp, 1)
// rldimi NewFPSCRTmpReg, ExtSrcReg, OldFPSCRReg, 0, 62
// copy NewFPSCRReg, NewFPSCRTmpReg
// mtfsf 255, NewFPSCRReg
MachineOperand SrcOp = MI.getOperand(1);
MachineRegisterInfo &RegInfo = F->getRegInfo();
Register OldFPSCRTmpReg = RegInfo.createVirtualRegister(&PPC::G8RCRegClass);
copyRegFromG8RCOrF8RC(OldFPSCRTmpReg, OldFPSCRReg);
Register ImDefReg = RegInfo.createVirtualRegister(&PPC::G8RCRegClass);
Register ExtSrcReg = RegInfo.createVirtualRegister(&PPC::G8RCRegClass);
// The first operand of INSERT_SUBREG should be a register which has
// subregisters, we only care about its RegClass, so we should use an
// IMPLICIT_DEF register.
BuildMI(*BB, MI, dl, TII->get(TargetOpcode::IMPLICIT_DEF), ImDefReg);
BuildMI(*BB, MI, dl, TII->get(PPC::INSERT_SUBREG), ExtSrcReg)
.addReg(ImDefReg)
.add(SrcOp)
.addImm(1);
Register NewFPSCRTmpReg = RegInfo.createVirtualRegister(&PPC::G8RCRegClass);
BuildMI(*BB, MI, dl, TII->get(PPC::RLDIMI), NewFPSCRTmpReg)
.addReg(OldFPSCRTmpReg)
.addReg(ExtSrcReg)
.addImm(0)
.addImm(62);
Register NewFPSCRReg = RegInfo.createVirtualRegister(&PPC::F8RCRegClass);
copyRegFromG8RCOrF8RC(NewFPSCRReg, NewFPSCRTmpReg);
// The mask 255 means that put the 32:63 bits of NewFPSCRReg to the 32:63
// bits of FPSCR.
BuildMI(*BB, MI, dl, TII->get(PPC::MTFSF))
.addImm(255)
.addReg(NewFPSCRReg)
.addImm(0)
.addImm(0);
} else if (MI.getOpcode() == PPC::SETFLM) {
DebugLoc Dl = MI.getDebugLoc();
// Result of setflm is previous FPSCR content, so we need to save it first.
Register OldFPSCRReg = MI.getOperand(0).getReg();
if (MRI.use_empty(OldFPSCRReg))
BuildMI(*BB, MI, Dl, TII->get(TargetOpcode::IMPLICIT_DEF), OldFPSCRReg);
else
BuildMI(*BB, MI, Dl, TII->get(PPC::MFFS), OldFPSCRReg);
// Put bits in 32:63 to FPSCR.
Register NewFPSCRReg = MI.getOperand(1).getReg();
BuildMI(*BB, MI, Dl, TII->get(PPC::MTFSF))
.addImm(255)
.addReg(NewFPSCRReg)
.addImm(0)
.addImm(0);
} else if (MI.getOpcode() == PPC::PROBED_ALLOCA_32 ||
MI.getOpcode() == PPC::PROBED_ALLOCA_64) {
return emitProbedAlloca(MI, BB);
} else if (MI.getOpcode() == PPC::SPLIT_QUADWORD) {
DebugLoc DL = MI.getDebugLoc();
Register Src = MI.getOperand(2).getReg();
Register Lo = MI.getOperand(0).getReg();
Register Hi = MI.getOperand(1).getReg();
BuildMI(*BB, MI, DL, TII->get(TargetOpcode::COPY))
.addDef(Lo)
.addUse(Src, 0, PPC::sub_gp8_x1);
BuildMI(*BB, MI, DL, TII->get(TargetOpcode::COPY))
.addDef(Hi)
.addUse(Src, 0, PPC::sub_gp8_x0);
} else if (MI.getOpcode() == PPC::LQX_PSEUDO ||
MI.getOpcode() == PPC::STQX_PSEUDO) {
DebugLoc DL = MI.getDebugLoc();
// Ptr is used as the ptr_rc_no_r0 part
// of LQ/STQ's memory operand and adding result of RA and RB,
// so it has to be g8rc_and_g8rc_nox0.
Register Ptr =
F->getRegInfo().createVirtualRegister(&PPC::G8RC_and_G8RC_NOX0RegClass);
Register Val = MI.getOperand(0).getReg();
Register RA = MI.getOperand(1).getReg();
Register RB = MI.getOperand(2).getReg();
BuildMI(*BB, MI, DL, TII->get(PPC::ADD8), Ptr).addReg(RA).addReg(RB);
BuildMI(*BB, MI, DL,
MI.getOpcode() == PPC::LQX_PSEUDO ? TII->get(PPC::LQ)
: TII->get(PPC::STQ))
.addReg(Val, MI.getOpcode() == PPC::LQX_PSEUDO ? RegState::Define : 0)
.addImm(0)
.addReg(Ptr);
} else {
llvm_unreachable("Unexpected instr type to insert");
}
MI.eraseFromParent(); // The pseudo instruction is gone now.
return BB;
}
//===----------------------------------------------------------------------===//
// Target Optimization Hooks
//===----------------------------------------------------------------------===//
static int getEstimateRefinementSteps(EVT VT, const PPCSubtarget &Subtarget) {
// For the estimates, convergence is quadratic, so we essentially double the
// number of digits correct after every iteration. For both FRE and FRSQRTE,
// the minimum architected relative accuracy is 2^-5. When hasRecipPrec(),
// this is 2^-14. IEEE float has 23 digits and double has 52 digits.
int RefinementSteps = Subtarget.hasRecipPrec() ? 1 : 3;
if (VT.getScalarType() == MVT::f64)
RefinementSteps++;
return RefinementSteps;
}
SDValue PPCTargetLowering::getSqrtInputTest(SDValue Op, SelectionDAG &DAG,
const DenormalMode &Mode) const {
// We only have VSX Vector Test for software Square Root.
EVT VT = Op.getValueType();
if (!isTypeLegal(MVT::i1) ||
(VT != MVT::f64 &&
((VT != MVT::v2f64 && VT != MVT::v4f32) || !Subtarget.hasVSX())))
return TargetLowering::getSqrtInputTest(Op, DAG, Mode);
SDLoc DL(Op);
// The output register of FTSQRT is CR field.
SDValue FTSQRT = DAG.getNode(PPCISD::FTSQRT, DL, MVT::i32, Op);
// ftsqrt BF,FRB
// Let e_b be the unbiased exponent of the double-precision
// floating-point operand in register FRB.
// fe_flag is set to 1 if either of the following conditions occurs.
// - The double-precision floating-point operand in register FRB is a zero,
// a NaN, or an infinity, or a negative value.
// - e_b is less than or equal to -970.
// Otherwise fe_flag is set to 0.
// Both VSX and non-VSX versions would set EQ bit in the CR if the number is
// not eligible for iteration. (zero/negative/infinity/nan or unbiased
// exponent is less than -970)
SDValue SRIdxVal = DAG.getTargetConstant(PPC::sub_eq, DL, MVT::i32);
return SDValue(DAG.getMachineNode(TargetOpcode::EXTRACT_SUBREG, DL, MVT::i1,
FTSQRT, SRIdxVal),
0);
}
SDValue
PPCTargetLowering::getSqrtResultForDenormInput(SDValue Op,
SelectionDAG &DAG) const {
// We only have VSX Vector Square Root.
EVT VT = Op.getValueType();
if (VT != MVT::f64 &&
((VT != MVT::v2f64 && VT != MVT::v4f32) || !Subtarget.hasVSX()))
return TargetLowering::getSqrtResultForDenormInput(Op, DAG);
return DAG.getNode(PPCISD::FSQRT, SDLoc(Op), VT, Op);
}
SDValue PPCTargetLowering::getSqrtEstimate(SDValue Operand, SelectionDAG &DAG,
int Enabled, int &RefinementSteps,
bool &UseOneConstNR,
bool Reciprocal) const {
EVT VT = Operand.getValueType();
if ((VT == MVT::f32 && Subtarget.hasFRSQRTES()) ||
(VT == MVT::f64 && Subtarget.hasFRSQRTE()) ||
(VT == MVT::v4f32 && Subtarget.hasAltivec()) ||
(VT == MVT::v2f64 && Subtarget.hasVSX())) {
if (RefinementSteps == ReciprocalEstimate::Unspecified)
RefinementSteps = getEstimateRefinementSteps(VT, Subtarget);
// The Newton-Raphson computation with a single constant does not provide
// enough accuracy on some CPUs.
UseOneConstNR = !Subtarget.needsTwoConstNR();
return DAG.getNode(PPCISD::FRSQRTE, SDLoc(Operand), VT, Operand);
}
return SDValue();
}
SDValue PPCTargetLowering::getRecipEstimate(SDValue Operand, SelectionDAG &DAG,
int Enabled,
int &RefinementSteps) const {
EVT VT = Operand.getValueType();
if ((VT == MVT::f32 && Subtarget.hasFRES()) ||
(VT == MVT::f64 && Subtarget.hasFRE()) ||
(VT == MVT::v4f32 && Subtarget.hasAltivec()) ||
(VT == MVT::v2f64 && Subtarget.hasVSX())) {
if (RefinementSteps == ReciprocalEstimate::Unspecified)
RefinementSteps = getEstimateRefinementSteps(VT, Subtarget);
return DAG.getNode(PPCISD::FRE, SDLoc(Operand), VT, Operand);
}
return SDValue();
}
unsigned PPCTargetLowering::combineRepeatedFPDivisors() const {
// Note: This functionality is used only when unsafe-fp-math is enabled, and
// on cores with reciprocal estimates (which are used when unsafe-fp-math is
// enabled for division), this functionality is redundant with the default
// combiner logic (once the division -> reciprocal/multiply transformation
// has taken place). As a result, this matters more for older cores than for
// newer ones.
// Combine multiple FDIVs with the same divisor into multiple FMULs by the
// reciprocal if there are two or more FDIVs (for embedded cores with only
// one FP pipeline) for three or more FDIVs (for generic OOO cores).
switch (Subtarget.getCPUDirective()) {
default:
return 3;
case PPC::DIR_440:
case PPC::DIR_A2:
case PPC::DIR_E500:
case PPC::DIR_E500mc:
case PPC::DIR_E5500:
return 2;
}
}
// isConsecutiveLSLoc needs to work even if all adds have not yet been
// collapsed, and so we need to look through chains of them.
static void getBaseWithConstantOffset(SDValue Loc, SDValue &Base,
int64_t& Offset, SelectionDAG &DAG) {
if (DAG.isBaseWithConstantOffset(Loc)) {
Base = Loc.getOperand(0);
Offset += cast<ConstantSDNode>(Loc.getOperand(1))->getSExtValue();
// The base might itself be a base plus an offset, and if so, accumulate
// that as well.
getBaseWithConstantOffset(Loc.getOperand(0), Base, Offset, DAG);
}
}
static bool isConsecutiveLSLoc(SDValue Loc, EVT VT, LSBaseSDNode *Base,
unsigned Bytes, int Dist,
SelectionDAG &DAG) {
if (VT.getSizeInBits() / 8 != Bytes)
return false;
SDValue BaseLoc = Base->getBasePtr();
if (Loc.getOpcode() == ISD::FrameIndex) {
if (BaseLoc.getOpcode() != ISD::FrameIndex)
return false;
const MachineFrameInfo &MFI = DAG.getMachineFunction().getFrameInfo();
int FI = cast<FrameIndexSDNode>(Loc)->getIndex();
int BFI = cast<FrameIndexSDNode>(BaseLoc)->getIndex();
int FS = MFI.getObjectSize(FI);
int BFS = MFI.getObjectSize(BFI);
if (FS != BFS || FS != (int)Bytes) return false;
return MFI.getObjectOffset(FI) == (MFI.getObjectOffset(BFI) + Dist*Bytes);
}
SDValue Base1 = Loc, Base2 = BaseLoc;
int64_t Offset1 = 0, Offset2 = 0;
getBaseWithConstantOffset(Loc, Base1, Offset1, DAG);
getBaseWithConstantOffset(BaseLoc, Base2, Offset2, DAG);
if (Base1 == Base2 && Offset1 == (Offset2 + Dist * Bytes))
return true;
const TargetLowering &TLI = DAG.getTargetLoweringInfo();
const GlobalValue *GV1 = nullptr;
const GlobalValue *GV2 = nullptr;
Offset1 = 0;
Offset2 = 0;
bool isGA1 = TLI.isGAPlusOffset(Loc.getNode(), GV1, Offset1);
bool isGA2 = TLI.isGAPlusOffset(BaseLoc.getNode(), GV2, Offset2);
if (isGA1 && isGA2 && GV1 == GV2)
return Offset1 == (Offset2 + Dist*Bytes);
return false;
}
// Like SelectionDAG::isConsecutiveLoad, but also works for stores, and does
// not enforce equality of the chain operands.
static bool isConsecutiveLS(SDNode *N, LSBaseSDNode *Base,
unsigned Bytes, int Dist,
SelectionDAG &DAG) {
if (LSBaseSDNode *LS = dyn_cast<LSBaseSDNode>(N)) {
EVT VT = LS->getMemoryVT();
SDValue Loc = LS->getBasePtr();
return isConsecutiveLSLoc(Loc, VT, Base, Bytes, Dist, DAG);
}
if (N->getOpcode() == ISD::INTRINSIC_W_CHAIN) {
EVT VT;
switch (cast<ConstantSDNode>(N->getOperand(1))->getZExtValue()) {
default: return false;
case Intrinsic::ppc_altivec_lvx:
case Intrinsic::ppc_altivec_lvxl:
case Intrinsic::ppc_vsx_lxvw4x:
case Intrinsic::ppc_vsx_lxvw4x_be:
VT = MVT::v4i32;
break;
case Intrinsic::ppc_vsx_lxvd2x:
case Intrinsic::ppc_vsx_lxvd2x_be:
VT = MVT::v2f64;
break;
case Intrinsic::ppc_altivec_lvebx:
VT = MVT::i8;
break;
case Intrinsic::ppc_altivec_lvehx:
VT = MVT::i16;
break;
case Intrinsic::ppc_altivec_lvewx:
VT = MVT::i32;
break;
}
return isConsecutiveLSLoc(N->getOperand(2), VT, Base, Bytes, Dist, DAG);
}
if (N->getOpcode() == ISD::INTRINSIC_VOID) {
EVT VT;
switch (cast<ConstantSDNode>(N->getOperand(1))->getZExtValue()) {
default: return false;
case Intrinsic::ppc_altivec_stvx:
case Intrinsic::ppc_altivec_stvxl:
case Intrinsic::ppc_vsx_stxvw4x:
VT = MVT::v4i32;
break;
case Intrinsic::ppc_vsx_stxvd2x:
VT = MVT::v2f64;
break;
case Intrinsic::ppc_vsx_stxvw4x_be:
VT = MVT::v4i32;
break;
case Intrinsic::ppc_vsx_stxvd2x_be:
VT = MVT::v2f64;
break;
case Intrinsic::ppc_altivec_stvebx:
VT = MVT::i8;
break;
case Intrinsic::ppc_altivec_stvehx:
VT = MVT::i16;
break;
case Intrinsic::ppc_altivec_stvewx:
VT = MVT::i32;
break;
}
return isConsecutiveLSLoc(N->getOperand(3), VT, Base, Bytes, Dist, DAG);
}
return false;
}
// Return true is there is a nearyby consecutive load to the one provided
// (regardless of alignment). We search up and down the chain, looking though
// token factors and other loads (but nothing else). As a result, a true result
// indicates that it is safe to create a new consecutive load adjacent to the
// load provided.
static bool findConsecutiveLoad(LoadSDNode *LD, SelectionDAG &DAG) {
SDValue Chain = LD->getChain();
EVT VT = LD->getMemoryVT();
SmallSet<SDNode *, 16> LoadRoots;
SmallVector<SDNode *, 8> Queue(1, Chain.getNode());
SmallSet<SDNode *, 16> Visited;
// First, search up the chain, branching to follow all token-factor operands.
// If we find a consecutive load, then we're done, otherwise, record all
// nodes just above the top-level loads and token factors.
while (!Queue.empty()) {
SDNode *ChainNext = Queue.pop_back_val();
if (!Visited.insert(ChainNext).second)
continue;
if (MemSDNode *ChainLD = dyn_cast<MemSDNode>(ChainNext)) {
if (isConsecutiveLS(ChainLD, LD, VT.getStoreSize(), 1, DAG))
return true;
if (!Visited.count(ChainLD->getChain().getNode()))
Queue.push_back(ChainLD->getChain().getNode());
} else if (ChainNext->getOpcode() == ISD::TokenFactor) {
for (const SDUse &O : ChainNext->ops())
if (!Visited.count(O.getNode()))
Queue.push_back(O.getNode());
} else
LoadRoots.insert(ChainNext);
}
// Second, search down the chain, starting from the top-level nodes recorded
// in the first phase. These top-level nodes are the nodes just above all
// loads and token factors. Starting with their uses, recursively look though
// all loads (just the chain uses) and token factors to find a consecutive
// load.
Visited.clear();
Queue.clear();
for (SmallSet<SDNode *, 16>::iterator I = LoadRoots.begin(),
IE = LoadRoots.end(); I != IE; ++I) {
Queue.push_back(*I);
while (!Queue.empty()) {
SDNode *LoadRoot = Queue.pop_back_val();
if (!Visited.insert(LoadRoot).second)
continue;
if (MemSDNode *ChainLD = dyn_cast<MemSDNode>(LoadRoot))
if (isConsecutiveLS(ChainLD, LD, VT.getStoreSize(), 1, DAG))
return true;
for (SDNode *U : LoadRoot->uses())
if (((isa<MemSDNode>(U) &&
cast<MemSDNode>(U)->getChain().getNode() == LoadRoot) ||
U->getOpcode() == ISD::TokenFactor) &&
!Visited.count(U))
Queue.push_back(U);
}
}
return false;
}
/// This function is called when we have proved that a SETCC node can be replaced
/// by subtraction (and other supporting instructions) so that the result of
/// comparison is kept in a GPR instead of CR. This function is purely for
/// codegen purposes and has some flags to guide the codegen process.
static SDValue generateEquivalentSub(SDNode *N, int Size, bool Complement,
bool Swap, SDLoc &DL, SelectionDAG &DAG) {
assert(N->getOpcode() == ISD::SETCC && "ISD::SETCC Expected.");
// Zero extend the operands to the largest legal integer. Originally, they
// must be of a strictly smaller size.
auto Op0 = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i64, N->getOperand(0),
DAG.getConstant(Size, DL, MVT::i32));
auto Op1 = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i64, N->getOperand(1),
DAG.getConstant(Size, DL, MVT::i32));
// Swap if needed. Depends on the condition code.
if (Swap)
std::swap(Op0, Op1);
// Subtract extended integers.
auto SubNode = DAG.getNode(ISD::SUB, DL, MVT::i64, Op0, Op1);
// Move the sign bit to the least significant position and zero out the rest.
// Now the least significant bit carries the result of original comparison.
auto Shifted = DAG.getNode(ISD::SRL, DL, MVT::i64, SubNode,
DAG.getConstant(Size - 1, DL, MVT::i32));
auto Final = Shifted;
// Complement the result if needed. Based on the condition code.
if (Complement)
Final = DAG.getNode(ISD::XOR, DL, MVT::i64, Shifted,
DAG.getConstant(1, DL, MVT::i64));
return DAG.getNode(ISD::TRUNCATE, DL, MVT::i1, Final);
}
SDValue PPCTargetLowering::ConvertSETCCToSubtract(SDNode *N,
DAGCombinerInfo &DCI) const {
assert(N->getOpcode() == ISD::SETCC && "ISD::SETCC Expected.");
SelectionDAG &DAG = DCI.DAG;
SDLoc DL(N);
// Size of integers being compared has a critical role in the following
// analysis, so we prefer to do this when all types are legal.
if (!DCI.isAfterLegalizeDAG())
return SDValue();
// If all users of SETCC extend its value to a legal integer type
// then we replace SETCC with a subtraction
for (const SDNode *U : N->uses())
if (U->getOpcode() != ISD::ZERO_EXTEND)
return SDValue();
ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get();
auto OpSize = N->getOperand(0).getValueSizeInBits();
unsigned Size = DAG.getDataLayout().getLargestLegalIntTypeSizeInBits();
if (OpSize < Size) {
switch (CC) {
default: break;
case ISD::SETULT:
return generateEquivalentSub(N, Size, false, false, DL, DAG);
case ISD::SETULE:
return generateEquivalentSub(N, Size, true, true, DL, DAG);
case ISD::SETUGT:
return generateEquivalentSub(N, Size, false, true, DL, DAG);
case ISD::SETUGE:
return generateEquivalentSub(N, Size, true, false, DL, DAG);
}
}
return SDValue();
}
SDValue PPCTargetLowering::DAGCombineTruncBoolExt(SDNode *N,
DAGCombinerInfo &DCI) const {
SelectionDAG &DAG = DCI.DAG;
SDLoc dl(N);
assert(Subtarget.useCRBits() && "Expecting to be tracking CR bits");
// If we're tracking CR bits, we need to be careful that we don't have:
// trunc(binary-ops(zext(x), zext(y)))
// or
// trunc(binary-ops(binary-ops(zext(x), zext(y)), ...)
// such that we're unnecessarily moving things into GPRs when it would be
// better to keep them in CR bits.
// Note that trunc here can be an actual i1 trunc, or can be the effective
// truncation that comes from a setcc or select_cc.
if (N->getOpcode() == ISD::TRUNCATE &&
N->getValueType(0) != MVT::i1)
return SDValue();
if (N->getOperand(0).getValueType() != MVT::i32 &&
N->getOperand(0).getValueType() != MVT::i64)
return SDValue();
if (N->getOpcode() == ISD::SETCC ||
N->getOpcode() == ISD::SELECT_CC) {
// If we're looking at a comparison, then we need to make sure that the
// high bits (all except for the first) don't matter the result.
ISD::CondCode CC =
cast<CondCodeSDNode>(N->getOperand(
N->getOpcode() == ISD::SETCC ? 2 : 4))->get();
unsigned OpBits = N->getOperand(0).getValueSizeInBits();
if (ISD::isSignedIntSetCC(CC)) {
if (DAG.ComputeNumSignBits(N->getOperand(0)) != OpBits ||
DAG.ComputeNumSignBits(N->getOperand(1)) != OpBits)
return SDValue();
} else if (ISD::isUnsignedIntSetCC(CC)) {
if (!DAG.MaskedValueIsZero(N->getOperand(0),
APInt::getHighBitsSet(OpBits, OpBits-1)) ||
!DAG.MaskedValueIsZero(N->getOperand(1),
APInt::getHighBitsSet(OpBits, OpBits-1)))
return (N->getOpcode() == ISD::SETCC ? ConvertSETCCToSubtract(N, DCI)
: SDValue());
} else {
// This is neither a signed nor an unsigned comparison, just make sure
// that the high bits are equal.
KnownBits Op1Known = DAG.computeKnownBits(N->getOperand(0));
KnownBits Op2Known = DAG.computeKnownBits(N->getOperand(1));
// We don't really care about what is known about the first bit (if
// anything), so pretend that it is known zero for both to ensure they can
// be compared as constants.
Op1Known.Zero.setBit(0); Op1Known.One.clearBit(0);
Op2Known.Zero.setBit(0); Op2Known.One.clearBit(0);
if (!Op1Known.isConstant() || !Op2Known.isConstant() ||
Op1Known.getConstant() != Op2Known.getConstant())
return SDValue();
}
}
// We now know that the higher-order bits are irrelevant, we just need to
// make sure that all of the intermediate operations are bit operations, and
// all inputs are extensions.
if (N->getOperand(0).getOpcode() != ISD::AND &&
N->getOperand(0).getOpcode() != ISD::OR &&
N->getOperand(0).getOpcode() != ISD::XOR &&
N->getOperand(0).getOpcode() != ISD::SELECT &&
N->getOperand(0).getOpcode() != ISD::SELECT_CC &&
N->getOperand(0).getOpcode() != ISD::TRUNCATE &&
N->getOperand(0).getOpcode() != ISD::SIGN_EXTEND &&
N->getOperand(0).getOpcode() != ISD::ZERO_EXTEND &&
N->getOperand(0).getOpcode() != ISD::ANY_EXTEND)
return SDValue();
if ((N->getOpcode() == ISD::SETCC || N->getOpcode() == ISD::SELECT_CC) &&
N->getOperand(1).getOpcode() != ISD::AND &&
N->getOperand(1).getOpcode() != ISD::OR &&
N->getOperand(1).getOpcode() != ISD::XOR &&
N->getOperand(1).getOpcode() != ISD::SELECT &&
N->getOperand(1).getOpcode() != ISD::SELECT_CC &&
N->getOperand(1).getOpcode() != ISD::TRUNCATE &&
N->getOperand(1).getOpcode() != ISD::SIGN_EXTEND &&
N->getOperand(1).getOpcode() != ISD::ZERO_EXTEND &&
N->getOperand(1).getOpcode() != ISD::ANY_EXTEND)
return SDValue();
SmallVector<SDValue, 4> Inputs;
SmallVector<SDValue, 8> BinOps, PromOps;
SmallPtrSet<SDNode *, 16> Visited;
for (unsigned i = 0; i < 2; ++i) {
if (((N->getOperand(i).getOpcode() == ISD::SIGN_EXTEND ||
N->getOperand(i).getOpcode() == ISD::ZERO_EXTEND ||
N->getOperand(i).getOpcode() == ISD::ANY_EXTEND) &&
N->getOperand(i).getOperand(0).getValueType() == MVT::i1) ||
isa<ConstantSDNode>(N->getOperand(i)))
Inputs.push_back(N->getOperand(i));
else
BinOps.push_back(N->getOperand(i));
if (N->getOpcode() == ISD::TRUNCATE)
break;
}
// Visit all inputs, collect all binary operations (and, or, xor and
// select) that are all fed by extensions.
while (!BinOps.empty()) {
SDValue BinOp = BinOps.pop_back_val();
if (!Visited.insert(BinOp.getNode()).second)
continue;
PromOps.push_back(BinOp);
for (unsigned i = 0, ie = BinOp.getNumOperands(); i != ie; ++i) {
// The condition of the select is not promoted.
if (BinOp.getOpcode() == ISD::SELECT && i == 0)
continue;
if (BinOp.getOpcode() == ISD::SELECT_CC && i != 2 && i != 3)
continue;
if (((BinOp.getOperand(i).getOpcode() == ISD::SIGN_EXTEND ||
BinOp.getOperand(i).getOpcode() == ISD::ZERO_EXTEND ||
BinOp.getOperand(i).getOpcode() == ISD::ANY_EXTEND) &&
BinOp.getOperand(i).getOperand(0).getValueType() == MVT::i1) ||
isa<ConstantSDNode>(BinOp.getOperand(i))) {
Inputs.push_back(BinOp.getOperand(i));
} else if (BinOp.getOperand(i).getOpcode() == ISD::AND ||
BinOp.getOperand(i).getOpcode() == ISD::OR ||
BinOp.getOperand(i).getOpcode() == ISD::XOR ||
BinOp.getOperand(i).getOpcode() == ISD::SELECT ||
BinOp.getOperand(i).getOpcode() == ISD::SELECT_CC ||
BinOp.getOperand(i).getOpcode() == ISD::TRUNCATE ||
BinOp.getOperand(i).getOpcode() == ISD::SIGN_EXTEND ||
BinOp.getOperand(i).getOpcode() == ISD::ZERO_EXTEND ||
BinOp.getOperand(i).getOpcode() == ISD::ANY_EXTEND) {
BinOps.push_back(BinOp.getOperand(i));
} else {
// We have an input that is not an extension or another binary
// operation; we'll abort this transformation.
return SDValue();
}
}
}
// Make sure that this is a self-contained cluster of operations (which
// is not quite the same thing as saying that everything has only one
// use).
for (unsigned i = 0, ie = Inputs.size(); i != ie; ++i) {
if (isa<ConstantSDNode>(Inputs[i]))
continue;
for (const SDNode *User : Inputs[i].getNode()->uses()) {
if (User != N && !Visited.count(User))
return SDValue();
// Make sure that we're not going to promote the non-output-value
// operand(s) or SELECT or SELECT_CC.
// FIXME: Although we could sometimes handle this, and it does occur in
// practice that one of the condition inputs to the select is also one of
// the outputs, we currently can't deal with this.
if (User->getOpcode() == ISD::SELECT) {
if (User->getOperand(0) == Inputs[i])
return SDValue();
} else if (User->getOpcode() == ISD::SELECT_CC) {
if (User->getOperand(0) == Inputs[i] ||
User->getOperand(1) == Inputs[i])
return SDValue();
}
}
}
for (unsigned i = 0, ie = PromOps.size(); i != ie; ++i) {
for (const SDNode *User : PromOps[i].getNode()->uses()) {
if (User != N && !Visited.count(User))
return SDValue();
// Make sure that we're not going to promote the non-output-value
// operand(s) or SELECT or SELECT_CC.
// FIXME: Although we could sometimes handle this, and it does occur in
// practice that one of the condition inputs to the select is also one of
// the outputs, we currently can't deal with this.
if (User->getOpcode() == ISD::SELECT) {
if (User->getOperand(0) == PromOps[i])
return SDValue();
} else if (User->getOpcode() == ISD::SELECT_CC) {
if (User->getOperand(0) == PromOps[i] ||
User->getOperand(1) == PromOps[i])
return SDValue();
}
}
}
// Replace all inputs with the extension operand.
for (unsigned i = 0, ie = Inputs.size(); i != ie; ++i) {
// Constants may have users outside the cluster of to-be-promoted nodes,
// and so we need to replace those as we do the promotions.
if (isa<ConstantSDNode>(Inputs[i]))
continue;
else
DAG.ReplaceAllUsesOfValueWith(Inputs[i], Inputs[i].getOperand(0));
}
std::list<HandleSDNode> PromOpHandles;
for (auto &PromOp : PromOps)
PromOpHandles.emplace_back(PromOp);
// Replace all operations (these are all the same, but have a different
// (i1) return type). DAG.getNode will validate that the types of
// a binary operator match, so go through the list in reverse so that
// we've likely promoted both operands first. Any intermediate truncations or
// extensions disappear.
while (!PromOpHandles.empty()) {
SDValue PromOp = PromOpHandles.back().getValue();
PromOpHandles.pop_back();
if (PromOp.getOpcode() == ISD::TRUNCATE ||
PromOp.getOpcode() == ISD::SIGN_EXTEND ||
PromOp.getOpcode() == ISD::ZERO_EXTEND ||
PromOp.getOpcode() == ISD::ANY_EXTEND) {
if (!isa<ConstantSDNode>(PromOp.getOperand(0)) &&
PromOp.getOperand(0).getValueType() != MVT::i1) {
// The operand is not yet ready (see comment below).
PromOpHandles.emplace_front(PromOp);
continue;
}
SDValue RepValue = PromOp.getOperand(0);
if (isa<ConstantSDNode>(RepValue))
RepValue = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, RepValue);
DAG.ReplaceAllUsesOfValueWith(PromOp, RepValue);
continue;
}
unsigned C;
switch (PromOp.getOpcode()) {
default: C = 0; break;
case ISD::SELECT: C = 1; break;
case ISD::SELECT_CC: C = 2; break;
}
if ((!isa<ConstantSDNode>(PromOp.getOperand(C)) &&
PromOp.getOperand(C).getValueType() != MVT::i1) ||
(!isa<ConstantSDNode>(PromOp.getOperand(C+1)) &&
PromOp.getOperand(C+1).getValueType() != MVT::i1)) {
// The to-be-promoted operands of this node have not yet been
// promoted (this should be rare because we're going through the
// list backward, but if one of the operands has several users in
// this cluster of to-be-promoted nodes, it is possible).
PromOpHandles.emplace_front(PromOp);
continue;
}
SmallVector<SDValue, 3> Ops(PromOp.getNode()->op_begin(),
PromOp.getNode()->op_end());
// If there are any constant inputs, make sure they're replaced now.
for (unsigned i = 0; i < 2; ++i)
if (isa<ConstantSDNode>(Ops[C+i]))
Ops[C+i] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, Ops[C+i]);
DAG.ReplaceAllUsesOfValueWith(PromOp,
DAG.getNode(PromOp.getOpcode(), dl, MVT::i1, Ops));
}
// Now we're left with the initial truncation itself.
if (N->getOpcode() == ISD::TRUNCATE)
return N->getOperand(0);
// Otherwise, this is a comparison. The operands to be compared have just
// changed type (to i1), but everything else is the same.
return SDValue(N, 0);
}
SDValue PPCTargetLowering::DAGCombineExtBoolTrunc(SDNode *N,
DAGCombinerInfo &DCI) const {
SelectionDAG &DAG = DCI.DAG;
SDLoc dl(N);
// If we're tracking CR bits, we need to be careful that we don't have:
// zext(binary-ops(trunc(x), trunc(y)))
// or
// zext(binary-ops(binary-ops(trunc(x), trunc(y)), ...)
// such that we're unnecessarily moving things into CR bits that can more
// efficiently stay in GPRs. Note that if we're not certain that the high
// bits are set as required by the final extension, we still may need to do
// some masking to get the proper behavior.
// This same functionality is important on PPC64 when dealing with
// 32-to-64-bit extensions; these occur often when 32-bit values are used as
// the return values of functions. Because it is so similar, it is handled
// here as well.
if (N->getValueType(0) != MVT::i32 &&
N->getValueType(0) != MVT::i64)
return SDValue();
if (!((N->getOperand(0).getValueType() == MVT::i1 && Subtarget.useCRBits()) ||
(N->getOperand(0).getValueType() == MVT::i32 && Subtarget.isPPC64())))
return SDValue();
if (N->getOperand(0).getOpcode() != ISD::AND &&
N->getOperand(0).getOpcode() != ISD::OR &&
N->getOperand(0).getOpcode() != ISD::XOR &&
N->getOperand(0).getOpcode() != ISD::SELECT &&
N->getOperand(0).getOpcode() != ISD::SELECT_CC)
return SDValue();
SmallVector<SDValue, 4> Inputs;
SmallVector<SDValue, 8> BinOps(1, N->getOperand(0)), PromOps;
SmallPtrSet<SDNode *, 16> Visited;
// Visit all inputs, collect all binary operations (and, or, xor and
// select) that are all fed by truncations.
while (!BinOps.empty()) {
SDValue BinOp = BinOps.pop_back_val();
if (!Visited.insert(BinOp.getNode()).second)
continue;
PromOps.push_back(BinOp);
for (unsigned i = 0, ie = BinOp.getNumOperands(); i != ie; ++i) {
// The condition of the select is not promoted.
if (BinOp.getOpcode() == ISD::SELECT && i == 0)
continue;
if (BinOp.getOpcode() == ISD::SELECT_CC && i != 2 && i != 3)
continue;
if (BinOp.getOperand(i).getOpcode() == ISD::TRUNCATE ||
isa<ConstantSDNode>(BinOp.getOperand(i))) {
Inputs.push_back(BinOp.getOperand(i));
} else if (BinOp.getOperand(i).getOpcode() == ISD::AND ||
BinOp.getOperand(i).getOpcode() == ISD::OR ||
BinOp.getOperand(i).getOpcode() == ISD::XOR ||
BinOp.getOperand(i).getOpcode() == ISD::SELECT ||
BinOp.getOperand(i).getOpcode() == ISD::SELECT_CC) {
BinOps.push_back(BinOp.getOperand(i));
} else {
// We have an input that is not a truncation or another binary
// operation; we'll abort this transformation.
return SDValue();
}
}
}
// The operands of a select that must be truncated when the select is
// promoted because the operand is actually part of the to-be-promoted set.
DenseMap<SDNode *, EVT> SelectTruncOp[2];
// Make sure that this is a self-contained cluster of operations (which
// is not quite the same thing as saying that everything has only one
// use).
for (unsigned i = 0, ie = Inputs.size(); i != ie; ++i) {
if (isa<ConstantSDNode>(Inputs[i]))
continue;
for (SDNode *User : Inputs[i].getNode()->uses()) {
if (User != N && !Visited.count(User))
return SDValue();
// If we're going to promote the non-output-value operand(s) or SELECT or
// SELECT_CC, record them for truncation.
if (User->getOpcode() == ISD::SELECT) {
if (User->getOperand(0) == Inputs[i])
SelectTruncOp[0].insert(std::make_pair(User,
User->getOperand(0).getValueType()));
} else if (User->getOpcode() == ISD::SELECT_CC) {
if (User->getOperand(0) == Inputs[i])
SelectTruncOp[0].insert(std::make_pair(User,
User->getOperand(0).getValueType()));
if (User->getOperand(1) == Inputs[i])
SelectTruncOp[1].insert(std::make_pair(User,
User->getOperand(1).getValueType()));
}
}
}
for (unsigned i = 0, ie = PromOps.size(); i != ie; ++i) {
for (SDNode *User : PromOps[i].getNode()->uses()) {
if (User != N && !Visited.count(User))
return SDValue();
// If we're going to promote the non-output-value operand(s) or SELECT or
// SELECT_CC, record them for truncation.
if (User->getOpcode() == ISD::SELECT) {
if (User->getOperand(0) == PromOps[i])
SelectTruncOp[0].insert(std::make_pair(User,
User->getOperand(0).getValueType()));
} else if (User->getOpcode() == ISD::SELECT_CC) {
if (User->getOperand(0) == PromOps[i])
SelectTruncOp[0].insert(std::make_pair(User,
User->getOperand(0).getValueType()));
if (User->getOperand(1) == PromOps[i])
SelectTruncOp[1].insert(std::make_pair(User,
User->getOperand(1).getValueType()));
}
}
}
unsigned PromBits = N->getOperand(0).getValueSizeInBits();
bool ReallyNeedsExt = false;
if (N->getOpcode() != ISD::ANY_EXTEND) {
// If all of the inputs are not already sign/zero extended, then
// we'll still need to do that at the end.
for (unsigned i = 0, ie = Inputs.size(); i != ie; ++i) {
if (isa<ConstantSDNode>(Inputs[i]))
continue;
unsigned OpBits =
Inputs[i].getOperand(0).getValueSizeInBits();
assert(PromBits < OpBits && "Truncation not to a smaller bit count?");
if ((N->getOpcode() == ISD::ZERO_EXTEND &&
!DAG.MaskedValueIsZero(Inputs[i].getOperand(0),
APInt::getHighBitsSet(OpBits,
OpBits-PromBits))) ||
(N->getOpcode() == ISD::SIGN_EXTEND &&
DAG.ComputeNumSignBits(Inputs[i].getOperand(0)) <
(OpBits-(PromBits-1)))) {
ReallyNeedsExt = true;
break;
}
}
}
// Replace all inputs, either with the truncation operand, or a
// truncation or extension to the final output type.
for (unsigned i = 0, ie = Inputs.size(); i != ie; ++i) {
// Constant inputs need to be replaced with the to-be-promoted nodes that
// use them because they might have users outside of the cluster of
// promoted nodes.
if (isa<ConstantSDNode>(Inputs[i]))
continue;
SDValue InSrc = Inputs[i].getOperand(0);
if (Inputs[i].getValueType() == N->getValueType(0))
DAG.ReplaceAllUsesOfValueWith(Inputs[i], InSrc);
else if (N->getOpcode() == ISD::SIGN_EXTEND)
DAG.ReplaceAllUsesOfValueWith(Inputs[i],
DAG.getSExtOrTrunc(InSrc, dl, N->getValueType(0)));
else if (N->getOpcode() == ISD::ZERO_EXTEND)
DAG.ReplaceAllUsesOfValueWith(Inputs[i],
DAG.getZExtOrTrunc(InSrc, dl, N->getValueType(0)));
else
DAG.ReplaceAllUsesOfValueWith(Inputs[i],
DAG.getAnyExtOrTrunc(InSrc, dl, N->getValueType(0)));
}
std::list<HandleSDNode> PromOpHandles;
for (auto &PromOp : PromOps)
PromOpHandles.emplace_back(PromOp);
// Replace all operations (these are all the same, but have a different
// (promoted) return type). DAG.getNode will validate that the types of
// a binary operator match, so go through the list in reverse so that
// we've likely promoted both operands first.
while (!PromOpHandles.empty()) {
SDValue PromOp = PromOpHandles.back().getValue();
PromOpHandles.pop_back();
unsigned C;
switch (PromOp.getOpcode()) {
default: C = 0; break;
case ISD::SELECT: C = 1; break;
case ISD::SELECT_CC: C = 2; break;
}
if ((!isa<ConstantSDNode>(PromOp.getOperand(C)) &&
PromOp.getOperand(C).getValueType() != N->getValueType(0)) ||
(!isa<ConstantSDNode>(PromOp.getOperand(C+1)) &&
PromOp.getOperand(C+1).getValueType() != N->getValueType(0))) {
// The to-be-promoted operands of this node have not yet been
// promoted (this should be rare because we're going through the
// list backward, but if one of the operands has several users in
// this cluster of to-be-promoted nodes, it is possible).
PromOpHandles.emplace_front(PromOp);
continue;
}
// For SELECT and SELECT_CC nodes, we do a similar check for any
// to-be-promoted comparison inputs.
if (PromOp.getOpcode() == ISD::SELECT ||
PromOp.getOpcode() == ISD::SELECT_CC) {
if ((SelectTruncOp[0].count(PromOp.getNode()) &&
PromOp.getOperand(0).getValueType() != N->getValueType(0)) ||
(SelectTruncOp[1].count(PromOp.getNode()) &&
PromOp.getOperand(1).getValueType() != N->getValueType(0))) {
PromOpHandles.emplace_front(PromOp);
continue;
}
}
SmallVector<SDValue, 3> Ops(PromOp.getNode()->op_begin(),
PromOp.getNode()->op_end());
// If this node has constant inputs, then they'll need to be promoted here.
for (unsigned i = 0; i < 2; ++i) {
if (!isa<ConstantSDNode>(Ops[C+i]))
continue;
if (Ops[C+i].getValueType() == N->getValueType(0))
continue;
if (N->getOpcode() == ISD::SIGN_EXTEND)
Ops[C+i] = DAG.getSExtOrTrunc(Ops[C+i], dl, N->getValueType(0));
else if (N->getOpcode() == ISD::ZERO_EXTEND)
Ops[C+i] = DAG.getZExtOrTrunc(Ops[C+i], dl, N->getValueType(0));
else
Ops[C+i] = DAG.getAnyExtOrTrunc(Ops[C+i], dl, N->getValueType(0));
}
// If we've promoted the comparison inputs of a SELECT or SELECT_CC,
// truncate them again to the original value type.
if (PromOp.getOpcode() == ISD::SELECT ||
PromOp.getOpcode() == ISD::SELECT_CC) {
auto SI0 = SelectTruncOp[0].find(PromOp.getNode());
if (SI0 != SelectTruncOp[0].end())
Ops[0] = DAG.getNode(ISD::TRUNCATE, dl, SI0->second, Ops[0]);
auto SI1 = SelectTruncOp[1].find(PromOp.getNode());
if (SI1 != SelectTruncOp[1].end())
Ops[1] = DAG.getNode(ISD::TRUNCATE, dl, SI1->second, Ops[1]);
}
DAG.ReplaceAllUsesOfValueWith(PromOp,
DAG.getNode(PromOp.getOpcode(), dl, N->getValueType(0), Ops));
}
// Now we're left with the initial extension itself.
if (!ReallyNeedsExt)
return N->getOperand(0);
// To zero extend, just mask off everything except for the first bit (in the
// i1 case).
if (N->getOpcode() == ISD::ZERO_EXTEND)
return DAG.getNode(ISD::AND, dl, N->getValueType(0), N->getOperand(0),
DAG.getConstant(APInt::getLowBitsSet(
N->getValueSizeInBits(0), PromBits),
dl, N->getValueType(0)));
assert(N->getOpcode() == ISD::SIGN_EXTEND &&
"Invalid extension type");
EVT ShiftAmountTy = getShiftAmountTy(N->getValueType(0), DAG.getDataLayout());
SDValue ShiftCst =
DAG.getConstant(N->getValueSizeInBits(0) - PromBits, dl, ShiftAmountTy);
return DAG.getNode(
ISD::SRA, dl, N->getValueType(0),
DAG.getNode(ISD::SHL, dl, N->getValueType(0), N->getOperand(0), ShiftCst),
ShiftCst);
}
SDValue PPCTargetLowering::combineSetCC(SDNode *N,
DAGCombinerInfo &DCI) const {
assert(N->getOpcode() == ISD::SETCC &&
"Should be called with a SETCC node");
ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get();
if (CC == ISD::SETNE || CC == ISD::SETEQ) {
SDValue LHS = N->getOperand(0);
SDValue RHS = N->getOperand(1);
// If there is a '0 - y' pattern, canonicalize the pattern to the RHS.
if (LHS.getOpcode() == ISD::SUB && isNullConstant(LHS.getOperand(0)) &&
LHS.hasOneUse())
std::swap(LHS, RHS);
// x == 0-y --> x+y == 0
// x != 0-y --> x+y != 0
if (RHS.getOpcode() == ISD::SUB && isNullConstant(RHS.getOperand(0)) &&
RHS.hasOneUse()) {
SDLoc DL(N);
SelectionDAG &DAG = DCI.DAG;
EVT VT = N->getValueType(0);
EVT OpVT = LHS.getValueType();
SDValue Add = DAG.getNode(ISD::ADD, DL, OpVT, LHS, RHS.getOperand(1));
return DAG.getSetCC(DL, VT, Add, DAG.getConstant(0, DL, OpVT), CC);
}
}
return DAGCombineTruncBoolExt(N, DCI);
}
// Is this an extending load from an f32 to an f64?
static bool isFPExtLoad(SDValue Op) {
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(Op.getNode()))
return LD->getExtensionType() == ISD::EXTLOAD &&
Op.getValueType() == MVT::f64;
return false;
}
/// Reduces the number of fp-to-int conversion when building a vector.
///
/// If this vector is built out of floating to integer conversions,
/// transform it to a vector built out of floating point values followed by a
/// single floating to integer conversion of the vector.
/// Namely (build_vector (fptosi $A), (fptosi $B), ...)
/// becomes (fptosi (build_vector ($A, $B, ...)))
SDValue PPCTargetLowering::
combineElementTruncationToVectorTruncation(SDNode *N,
DAGCombinerInfo &DCI) const {
assert(N->getOpcode() == ISD::BUILD_VECTOR &&
"Should be called with a BUILD_VECTOR node");
SelectionDAG &DAG = DCI.DAG;
SDLoc dl(N);
SDValue FirstInput = N->getOperand(0);
assert(FirstInput.getOpcode() == PPCISD::MFVSR &&
"The input operand must be an fp-to-int conversion.");
// This combine happens after legalization so the fp_to_[su]i nodes are
// already converted to PPCSISD nodes.
unsigned FirstConversion = FirstInput.getOperand(0).getOpcode();
if (FirstConversion == PPCISD::FCTIDZ ||
FirstConversion == PPCISD::FCTIDUZ ||
FirstConversion == PPCISD::FCTIWZ ||
FirstConversion == PPCISD::FCTIWUZ) {
bool IsSplat = true;
bool Is32Bit = FirstConversion == PPCISD::FCTIWZ ||
FirstConversion == PPCISD::FCTIWUZ;
EVT SrcVT = FirstInput.getOperand(0).getValueType();
SmallVector<SDValue, 4> Ops;
EVT TargetVT = N->getValueType(0);
for (int i = 0, e = N->getNumOperands(); i < e; ++i) {
SDValue NextOp = N->getOperand(i);
if (NextOp.getOpcode() != PPCISD::MFVSR)
return SDValue();
unsigned NextConversion = NextOp.getOperand(0).getOpcode();
if (NextConversion != FirstConversion)
return SDValue();
// If we are converting to 32-bit integers, we need to add an FP_ROUND.
// This is not valid if the input was originally double precision. It is
// also not profitable to do unless this is an extending load in which
// case doing this combine will allow us to combine consecutive loads.
if (Is32Bit && !isFPExtLoad(NextOp.getOperand(0).getOperand(0)))
return SDValue();
if (N->getOperand(i) != FirstInput)
IsSplat = false;
}
// If this is a splat, we leave it as-is since there will be only a single
// fp-to-int conversion followed by a splat of the integer. This is better
// for 32-bit and smaller ints and neutral for 64-bit ints.
if (IsSplat)
return SDValue();
// Now that we know we have the right type of node, get its operands
for (int i = 0, e = N->getNumOperands(); i < e; ++i) {
SDValue In = N->getOperand(i).getOperand(0);
if (Is32Bit) {
// For 32-bit values, we need to add an FP_ROUND node (if we made it
// here, we know that all inputs are extending loads so this is safe).
if (In.isUndef())
Ops.push_back(DAG.getUNDEF(SrcVT));
else {
SDValue Trunc = DAG.getNode(ISD::FP_ROUND, dl,
MVT::f32, In.getOperand(0),
DAG.getIntPtrConstant(1, dl));
Ops.push_back(Trunc);
}
} else
Ops.push_back(In.isUndef() ? DAG.getUNDEF(SrcVT) : In.getOperand(0));
}
unsigned Opcode;
if (FirstConversion == PPCISD::FCTIDZ ||
FirstConversion == PPCISD::FCTIWZ)
Opcode = ISD::FP_TO_SINT;
else
Opcode = ISD::FP_TO_UINT;
EVT NewVT = TargetVT == MVT::v2i64 ? MVT::v2f64 : MVT::v4f32;
SDValue BV = DAG.getBuildVector(NewVT, dl, Ops);
return DAG.getNode(Opcode, dl, TargetVT, BV);
}
return SDValue();
}
/// Reduce the number of loads when building a vector.
///
/// Building a vector out of multiple loads can be converted to a load
/// of the vector type if the loads are consecutive. If the loads are
/// consecutive but in descending order, a shuffle is added at the end
/// to reorder the vector.
static SDValue combineBVOfConsecutiveLoads(SDNode *N, SelectionDAG &DAG) {
assert(N->getOpcode() == ISD::BUILD_VECTOR &&
"Should be called with a BUILD_VECTOR node");
SDLoc dl(N);
// Return early for non byte-sized type, as they can't be consecutive.
if (!N->getValueType(0).getVectorElementType().isByteSized())
return SDValue();
bool InputsAreConsecutiveLoads = true;
bool InputsAreReverseConsecutive = true;
unsigned ElemSize = N->getValueType(0).getScalarType().getStoreSize();
SDValue FirstInput = N->getOperand(0);
bool IsRoundOfExtLoad = false;
if (FirstInput.getOpcode() == ISD::FP_ROUND &&
FirstInput.getOperand(0).getOpcode() == ISD::LOAD) {
LoadSDNode *LD = dyn_cast<LoadSDNode>(FirstInput.getOperand(0));
IsRoundOfExtLoad = LD->getExtensionType() == ISD::EXTLOAD;
}
// Not a build vector of (possibly fp_rounded) loads.
if ((!IsRoundOfExtLoad && FirstInput.getOpcode() != ISD::LOAD) ||
N->getNumOperands() == 1)
return SDValue();
for (int i = 1, e = N->getNumOperands(); i < e; ++i) {
// If any inputs are fp_round(extload), they all must be.
if (IsRoundOfExtLoad && N->getOperand(i).getOpcode() != ISD::FP_ROUND)
return SDValue();
SDValue NextInput = IsRoundOfExtLoad ? N->getOperand(i).getOperand(0) :
N->getOperand(i);
if (NextInput.getOpcode() != ISD::LOAD)
return SDValue();
SDValue PreviousInput =
IsRoundOfExtLoad ? N->getOperand(i-1).getOperand(0) : N->getOperand(i-1);
LoadSDNode *LD1 = dyn_cast<LoadSDNode>(PreviousInput);
LoadSDNode *LD2 = dyn_cast<LoadSDNode>(NextInput);
// If any inputs are fp_round(extload), they all must be.
if (IsRoundOfExtLoad && LD2->getExtensionType() != ISD::EXTLOAD)
return SDValue();
if (!isConsecutiveLS(LD2, LD1, ElemSize, 1, DAG))
InputsAreConsecutiveLoads = false;
if (!isConsecutiveLS(LD1, LD2, ElemSize, 1, DAG))
InputsAreReverseConsecutive = false;
// Exit early if the loads are neither consecutive nor reverse consecutive.
if (!InputsAreConsecutiveLoads && !InputsAreReverseConsecutive)
return SDValue();
}
assert(!(InputsAreConsecutiveLoads && InputsAreReverseConsecutive) &&
"The loads cannot be both consecutive and reverse consecutive.");
SDValue FirstLoadOp =
IsRoundOfExtLoad ? FirstInput.getOperand(0) : FirstInput;
SDValue LastLoadOp =
IsRoundOfExtLoad ? N->getOperand(N->getNumOperands()-1).getOperand(0) :
N->getOperand(N->getNumOperands()-1);
LoadSDNode *LD1 = dyn_cast<LoadSDNode>(FirstLoadOp);
LoadSDNode *LDL = dyn_cast<LoadSDNode>(LastLoadOp);
if (InputsAreConsecutiveLoads) {
assert(LD1 && "Input needs to be a LoadSDNode.");
return DAG.getLoad(N->getValueType(0), dl, LD1->getChain(),
LD1->getBasePtr(), LD1->getPointerInfo(),
LD1->getAlignment());
}
if (InputsAreReverseConsecutive) {
assert(LDL && "Input needs to be a LoadSDNode.");
SDValue Load = DAG.getLoad(N->getValueType(0), dl, LDL->getChain(),
LDL->getBasePtr(), LDL->getPointerInfo(),
LDL->getAlignment());
SmallVector<int, 16> Ops;
for (int i = N->getNumOperands() - 1; i >= 0; i--)
Ops.push_back(i);
return DAG.getVectorShuffle(N->getValueType(0), dl, Load,
DAG.getUNDEF(N->getValueType(0)), Ops);
}
return SDValue();
}
// This function adds the required vector_shuffle needed to get
// the elements of the vector extract in the correct position
// as specified by the CorrectElems encoding.
static SDValue addShuffleForVecExtend(SDNode *N, SelectionDAG &DAG,
SDValue Input, uint64_t Elems,
uint64_t CorrectElems) {
SDLoc dl(N);
unsigned NumElems = Input.getValueType().getVectorNumElements();
SmallVector<int, 16> ShuffleMask(NumElems, -1);
// Knowing the element indices being extracted from the original
// vector and the order in which they're being inserted, just put
// them at element indices required for the instruction.
for (unsigned i = 0; i < N->getNumOperands(); i++) {
if (DAG.getDataLayout().isLittleEndian())
ShuffleMask[CorrectElems & 0xF] = Elems & 0xF;
else
ShuffleMask[(CorrectElems & 0xF0) >> 4] = (Elems & 0xF0) >> 4;
CorrectElems = CorrectElems >> 8;
Elems = Elems >> 8;
}
SDValue Shuffle =
DAG.getVectorShuffle(Input.getValueType(), dl, Input,
DAG.getUNDEF(Input.getValueType()), ShuffleMask);
EVT VT = N->getValueType(0);
SDValue Conv = DAG.getBitcast(VT, Shuffle);
EVT ExtVT = EVT::getVectorVT(*DAG.getContext(),
Input.getValueType().getVectorElementType(),
VT.getVectorNumElements());
return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, VT, Conv,
DAG.getValueType(ExtVT));
}
// Look for build vector patterns where input operands come from sign
// extended vector_extract elements of specific indices. If the correct indices
// aren't used, add a vector shuffle to fix up the indices and create
// SIGN_EXTEND_INREG node which selects the vector sign extend instructions
// during instruction selection.
static SDValue combineBVOfVecSExt(SDNode *N, SelectionDAG &DAG) {
// This array encodes the indices that the vector sign extend instructions
// extract from when extending from one type to another for both BE and LE.
// The right nibble of each byte corresponds to the LE incides.
// and the left nibble of each byte corresponds to the BE incides.
// For example: 0x3074B8FC byte->word
// For LE: the allowed indices are: 0x0,0x4,0x8,0xC
// For BE: the allowed indices are: 0x3,0x7,0xB,0xF
// For example: 0x000070F8 byte->double word
// For LE: the allowed indices are: 0x0,0x8
// For BE: the allowed indices are: 0x7,0xF
uint64_t TargetElems[] = {
0x3074B8FC, // b->w
0x000070F8, // b->d
0x10325476, // h->w
0x00003074, // h->d
0x00001032, // w->d
};
uint64_t Elems = 0;
int Index;
SDValue Input;
auto isSExtOfVecExtract = [&](SDValue Op) -> bool {
if (!Op)
return false;
if (Op.getOpcode() != ISD::SIGN_EXTEND &&
Op.getOpcode() != ISD::SIGN_EXTEND_INREG)
return false;
// A SIGN_EXTEND_INREG might be fed by an ANY_EXTEND to produce a value
// of the right width.
SDValue Extract = Op.getOperand(0);
if (Extract.getOpcode() == ISD::ANY_EXTEND)
Extract = Extract.getOperand(0);
if (Extract.getOpcode() != ISD::EXTRACT_VECTOR_ELT)
return false;
ConstantSDNode *ExtOp = dyn_cast<ConstantSDNode>(Extract.getOperand(1));
if (!ExtOp)
return false;
Index = ExtOp->getZExtValue();
if (Input && Input != Extract.getOperand(0))
return false;
if (!Input)
Input = Extract.getOperand(0);
Elems = Elems << 8;
Index = DAG.getDataLayout().isLittleEndian() ? Index : Index << 4;
Elems |= Index;
return true;
};
// If the build vector operands aren't sign extended vector extracts,
// of the same input vector, then return.
for (unsigned i = 0; i < N->getNumOperands(); i++) {
if (!isSExtOfVecExtract(N->getOperand(i))) {
return SDValue();
}
}
// If the vector extract indicies are not correct, add the appropriate
// vector_shuffle.
int TgtElemArrayIdx;
int InputSize = Input.getValueType().getScalarSizeInBits();
int OutputSize = N->getValueType(0).getScalarSizeInBits();
if (InputSize + OutputSize == 40)
TgtElemArrayIdx = 0;
else if (InputSize + OutputSize == 72)
TgtElemArrayIdx = 1;
else if (InputSize + OutputSize == 48)
TgtElemArrayIdx = 2;
else if (InputSize + OutputSize == 80)
TgtElemArrayIdx = 3;
else if (InputSize + OutputSize == 96)
TgtElemArrayIdx = 4;
else
return SDValue();
uint64_t CorrectElems = TargetElems[TgtElemArrayIdx];
CorrectElems = DAG.getDataLayout().isLittleEndian()
? CorrectElems & 0x0F0F0F0F0F0F0F0F
: CorrectElems & 0xF0F0F0F0F0F0F0F0;
if (Elems != CorrectElems) {
return addShuffleForVecExtend(N, DAG, Input, Elems, CorrectElems);
}
// Regular lowering will catch cases where a shuffle is not needed.
return SDValue();
}
// Look for the pattern of a load from a narrow width to i128, feeding
// into a BUILD_VECTOR of v1i128. Replace this sequence with a PPCISD node
// (LXVRZX). This node represents a zero extending load that will be matched
// to the Load VSX Vector Rightmost instructions.
static SDValue combineBVZEXTLOAD(SDNode *N, SelectionDAG &DAG) {
SDLoc DL(N);
// This combine is only eligible for a BUILD_VECTOR of v1i128.
if (N->getValueType(0) != MVT::v1i128)
return SDValue();
SDValue Operand = N->getOperand(0);
// Proceed with the transformation if the operand to the BUILD_VECTOR
// is a load instruction.
if (Operand.getOpcode() != ISD::LOAD)
return SDValue();
auto *LD = cast<LoadSDNode>(Operand);
EVT MemoryType = LD->getMemoryVT();
// This transformation is only valid if the we are loading either a byte,
// halfword, word, or doubleword.
bool ValidLDType = MemoryType == MVT::i8 || MemoryType == MVT::i16 ||
MemoryType == MVT::i32 || MemoryType == MVT::i64;
// Ensure that the load from the narrow width is being zero extended to i128.
if (!ValidLDType ||
(LD->getExtensionType() != ISD::ZEXTLOAD &&
LD->getExtensionType() != ISD::EXTLOAD))
return SDValue();
SDValue LoadOps[] = {
LD->getChain(), LD->getBasePtr(),
DAG.getIntPtrConstant(MemoryType.getScalarSizeInBits(), DL)};
return DAG.getMemIntrinsicNode(PPCISD::LXVRZX, DL,
DAG.getVTList(MVT::v1i128, MVT::Other),
LoadOps, MemoryType, LD->getMemOperand());
}
SDValue PPCTargetLowering::DAGCombineBuildVector(SDNode *N,
DAGCombinerInfo &DCI) const {
assert(N->getOpcode() == ISD::BUILD_VECTOR &&
"Should be called with a BUILD_VECTOR node");
SelectionDAG &DAG = DCI.DAG;
SDLoc dl(N);
if (!Subtarget.hasVSX())
return SDValue();
// The target independent DAG combiner will leave a build_vector of
// float-to-int conversions intact. We can generate MUCH better code for
// a float-to-int conversion of a vector of floats.
SDValue FirstInput = N->getOperand(0);
if (FirstInput.getOpcode() == PPCISD::MFVSR) {
SDValue Reduced = combineElementTruncationToVectorTruncation(N, DCI);
if (Reduced)
return Reduced;
}
// If we're building a vector out of consecutive loads, just load that
// vector type.
SDValue Reduced = combineBVOfConsecutiveLoads(N, DAG);
if (Reduced)
return Reduced;
// If we're building a vector out of extended elements from another vector
// we have P9 vector integer extend instructions. The code assumes legal
// input types (i.e. it can't handle things like v4i16) so do not run before
// legalization.
if (Subtarget.hasP9Altivec() && !DCI.isBeforeLegalize()) {
Reduced = combineBVOfVecSExt(N, DAG);
if (Reduced)
return Reduced;
}
// On Power10, the Load VSX Vector Rightmost instructions can be utilized
// if this is a BUILD_VECTOR of v1i128, and if the operand to the BUILD_VECTOR
// is a load from <valid narrow width> to i128.
if (Subtarget.isISA3_1()) {
SDValue BVOfZLoad = combineBVZEXTLOAD(N, DAG);
if (BVOfZLoad)
return BVOfZLoad;
}
if (N->getValueType(0) != MVT::v2f64)
return SDValue();
// Looking for:
// (build_vector ([su]int_to_fp (extractelt 0)), [su]int_to_fp (extractelt 1))
if (FirstInput.getOpcode() != ISD::SINT_TO_FP &&
FirstInput.getOpcode() != ISD::UINT_TO_FP)
return SDValue();
if (N->getOperand(1).getOpcode() != ISD::SINT_TO_FP &&
N->getOperand(1).getOpcode() != ISD::UINT_TO_FP)
return SDValue();
if (FirstInput.getOpcode() != N->getOperand(1).getOpcode())
return SDValue();
SDValue Ext1 = FirstInput.getOperand(0);
SDValue Ext2 = N->getOperand(1).getOperand(0);
if(Ext1.getOpcode() != ISD::EXTRACT_VECTOR_ELT ||
Ext2.getOpcode() != ISD::EXTRACT_VECTOR_ELT)
return SDValue();
ConstantSDNode *Ext1Op = dyn_cast<ConstantSDNode>(Ext1.getOperand(1));
ConstantSDNode *Ext2Op = dyn_cast<ConstantSDNode>(Ext2.getOperand(1));
if (!Ext1Op || !Ext2Op)
return SDValue();
if (Ext1.getOperand(0).getValueType() != MVT::v4i32 ||
Ext1.getOperand(0) != Ext2.getOperand(0))
return SDValue();
int FirstElem = Ext1Op->getZExtValue();
int SecondElem = Ext2Op->getZExtValue();
int SubvecIdx;
if (FirstElem == 0 && SecondElem == 1)
SubvecIdx = Subtarget.isLittleEndian() ? 1 : 0;
else if (FirstElem == 2 && SecondElem == 3)
SubvecIdx = Subtarget.isLittleEndian() ? 0 : 1;
else
return SDValue();
SDValue SrcVec = Ext1.getOperand(0);
auto NodeType = (N->getOperand(1).getOpcode() == ISD::SINT_TO_FP) ?
PPCISD::SINT_VEC_TO_FP : PPCISD::UINT_VEC_TO_FP;
return DAG.getNode(NodeType, dl, MVT::v2f64,
SrcVec, DAG.getIntPtrConstant(SubvecIdx, dl));
}
SDValue PPCTargetLowering::combineFPToIntToFP(SDNode *N,
DAGCombinerInfo &DCI) const {
assert((N->getOpcode() == ISD::SINT_TO_FP ||
N->getOpcode() == ISD::UINT_TO_FP) &&
"Need an int -> FP conversion node here");
if (useSoftFloat() || !Subtarget.has64BitSupport())
return SDValue();
SelectionDAG &DAG = DCI.DAG;
SDLoc dl(N);
SDValue Op(N, 0);
// Don't handle ppc_fp128 here or conversions that are out-of-range capable
// from the hardware.
if (Op.getValueType() != MVT::f32 && Op.getValueType() != MVT::f64)
return SDValue();
if (!Op.getOperand(0).getValueType().isSimple())
return SDValue();
if (Op.getOperand(0).getValueType().getSimpleVT() <= MVT(MVT::i1) ||
Op.getOperand(0).getValueType().getSimpleVT() > MVT(MVT::i64))
return SDValue();
SDValue FirstOperand(Op.getOperand(0));
bool SubWordLoad = FirstOperand.getOpcode() == ISD::LOAD &&
(FirstOperand.getValueType() == MVT::i8 ||
FirstOperand.getValueType() == MVT::i16);
if (Subtarget.hasP9Vector() && Subtarget.hasP9Altivec() && SubWordLoad) {
bool Signed = N->getOpcode() == ISD::SINT_TO_FP;
bool DstDouble = Op.getValueType() == MVT::f64;
unsigned ConvOp = Signed ?
(DstDouble ? PPCISD::FCFID : PPCISD::FCFIDS) :
(DstDouble ? PPCISD::FCFIDU : PPCISD::FCFIDUS);
SDValue WidthConst =
DAG.getIntPtrConstant(FirstOperand.getValueType() == MVT::i8 ? 1 : 2,
dl, false);
LoadSDNode *LDN = cast<LoadSDNode>(FirstOperand.getNode());
SDValue Ops[] = { LDN->getChain(), LDN->getBasePtr(), WidthConst };
SDValue Ld = DAG.getMemIntrinsicNode(PPCISD::LXSIZX, dl,
DAG.getVTList(MVT::f64, MVT::Other),
Ops, MVT::i8, LDN->getMemOperand());
// For signed conversion, we need to sign-extend the value in the VSR
if (Signed) {
SDValue ExtOps[] = { Ld, WidthConst };
SDValue Ext = DAG.getNode(PPCISD::VEXTS, dl, MVT::f64, ExtOps);
return DAG.getNode(ConvOp, dl, DstDouble ? MVT::f64 : MVT::f32, Ext);
} else
return DAG.getNode(ConvOp, dl, DstDouble ? MVT::f64 : MVT::f32, Ld);
}
// For i32 intermediate values, unfortunately, the conversion functions
// leave the upper 32 bits of the value are undefined. Within the set of
// scalar instructions, we have no method for zero- or sign-extending the
// value. Thus, we cannot handle i32 intermediate values here.
if (Op.getOperand(0).getValueType() == MVT::i32)
return SDValue();
assert((Op.getOpcode() == ISD::SINT_TO_FP || Subtarget.hasFPCVT()) &&
"UINT_TO_FP is supported only with FPCVT");
// If we have FCFIDS, then use it when converting to single-precision.
// Otherwise, convert to double-precision and then round.
unsigned FCFOp = (Subtarget.hasFPCVT() && Op.getValueType() == MVT::f32)
? (Op.getOpcode() == ISD::UINT_TO_FP ? PPCISD::FCFIDUS
: PPCISD::FCFIDS)
: (Op.getOpcode() == ISD::UINT_TO_FP ? PPCISD::FCFIDU
: PPCISD::FCFID);
MVT FCFTy = (Subtarget.hasFPCVT() && Op.getValueType() == MVT::f32)
? MVT::f32
: MVT::f64;
// If we're converting from a float, to an int, and back to a float again,
// then we don't need the store/load pair at all.
if ((Op.getOperand(0).getOpcode() == ISD::FP_TO_UINT &&
Subtarget.hasFPCVT()) ||
(Op.getOperand(0).getOpcode() == ISD::FP_TO_SINT)) {
SDValue Src = Op.getOperand(0).getOperand(0);
if (Src.getValueType() == MVT::f32) {
Src = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Src);
DCI.AddToWorklist(Src.getNode());
} else if (Src.getValueType() != MVT::f64) {
// Make sure that we don't pick up a ppc_fp128 source value.
return SDValue();
}
unsigned FCTOp =
Op.getOperand(0).getOpcode() == ISD::FP_TO_SINT ? PPCISD::FCTIDZ :
PPCISD::FCTIDUZ;
SDValue Tmp = DAG.getNode(FCTOp, dl, MVT::f64, Src);
SDValue FP = DAG.getNode(FCFOp, dl, FCFTy, Tmp);
if (Op.getValueType() == MVT::f32 && !Subtarget.hasFPCVT()) {
FP = DAG.getNode(ISD::FP_ROUND, dl,
MVT::f32, FP, DAG.getIntPtrConstant(0, dl));
DCI.AddToWorklist(FP.getNode());
}
return FP;
}
return SDValue();
}
// expandVSXLoadForLE - Convert VSX loads (which may be intrinsics for
// builtins) into loads with swaps.
SDValue PPCTargetLowering::expandVSXLoadForLE(SDNode *N,
DAGCombinerInfo &DCI) const {
SelectionDAG &DAG = DCI.DAG;
SDLoc dl(N);
SDValue Chain;
SDValue Base;
MachineMemOperand *MMO;
switch (N->getOpcode()) {
default:
llvm_unreachable("Unexpected opcode for little endian VSX load");
case ISD::LOAD: {
LoadSDNode *LD = cast<LoadSDNode>(N);
Chain = LD->getChain();
Base = LD->getBasePtr();
MMO = LD->getMemOperand();
// If the MMO suggests this isn't a load of a full vector, leave
// things alone. For a built-in, we have to make the change for
// correctness, so if there is a size problem that will be a bug.
if (MMO->getSize() < 16)
return SDValue();
break;
}
case ISD::INTRINSIC_W_CHAIN: {
MemIntrinsicSDNode *Intrin = cast<MemIntrinsicSDNode>(N);
Chain = Intrin->getChain();
// Similarly to the store case below, Intrin->getBasePtr() doesn't get
// us what we want. Get operand 2 instead.
Base = Intrin->getOperand(2);
MMO = Intrin->getMemOperand();
break;
}
}
MVT VecTy = N->getValueType(0).getSimpleVT();
// Do not expand to PPCISD::LXVD2X + PPCISD::XXSWAPD when the load is
// aligned and the type is a vector with elements up to 4 bytes
if (Subtarget.needsSwapsForVSXMemOps() && MMO->getAlign() >= Align(16) &&
VecTy.getScalarSizeInBits() <= 32) {
return SDValue();
}
SDValue LoadOps[] = { Chain, Base };
SDValue Load = DAG.getMemIntrinsicNode(PPCISD::LXVD2X, dl,
DAG.getVTList(MVT::v2f64, MVT::Other),
LoadOps, MVT::v2f64, MMO);
DCI.AddToWorklist(Load.getNode());
Chain = Load.getValue(1);
SDValue Swap = DAG.getNode(
PPCISD::XXSWAPD, dl, DAG.getVTList(MVT::v2f64, MVT::Other), Chain, Load);
DCI.AddToWorklist(Swap.getNode());
// Add a bitcast if the resulting load type doesn't match v2f64.
if (VecTy != MVT::v2f64) {
SDValue N = DAG.getNode(ISD::BITCAST, dl, VecTy, Swap);
DCI.AddToWorklist(N.getNode());
// Package {bitcast value, swap's chain} to match Load's shape.
return DAG.getNode(ISD::MERGE_VALUES, dl, DAG.getVTList(VecTy, MVT::Other),
N, Swap.getValue(1));
}
return Swap;
}
// expandVSXStoreForLE - Convert VSX stores (which may be intrinsics for
// builtins) into stores with swaps.
SDValue PPCTargetLowering::expandVSXStoreForLE(SDNode *N,
DAGCombinerInfo &DCI) const {
SelectionDAG &DAG = DCI.DAG;
SDLoc dl(N);
SDValue Chain;
SDValue Base;
unsigned SrcOpnd;
MachineMemOperand *MMO;
switch (N->getOpcode()) {
default:
llvm_unreachable("Unexpected opcode for little endian VSX store");
case ISD::STORE: {
StoreSDNode *ST = cast<StoreSDNode>(N);
Chain = ST->getChain();
Base = ST->getBasePtr();
MMO = ST->getMemOperand();
SrcOpnd = 1;
// If the MMO suggests this isn't a store of a full vector, leave
// things alone. For a built-in, we have to make the change for
// correctness, so if there is a size problem that will be a bug.
if (MMO->getSize() < 16)
return SDValue();
break;
}
case ISD::INTRINSIC_VOID: {
MemIntrinsicSDNode *Intrin = cast<MemIntrinsicSDNode>(N);
Chain = Intrin->getChain();
// Intrin->getBasePtr() oddly does not get what we want.
Base = Intrin->getOperand(3);
MMO = Intrin->getMemOperand();
SrcOpnd = 2;
break;
}
}
SDValue Src = N->getOperand(SrcOpnd);
MVT VecTy = Src.getValueType().getSimpleVT();
// Do not expand to PPCISD::XXSWAPD and PPCISD::STXVD2X when the load is
// aligned and the type is a vector with elements up to 4 bytes
if (Subtarget.needsSwapsForVSXMemOps() && MMO->getAlign() >= Align(16) &&
VecTy.getScalarSizeInBits() <= 32) {
return SDValue();
}
// All stores are done as v2f64 and possible bit cast.
if (VecTy != MVT::v2f64) {
Src = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Src);
DCI.AddToWorklist(Src.getNode());
}
SDValue Swap = DAG.getNode(PPCISD::XXSWAPD, dl,
DAG.getVTList(MVT::v2f64, MVT::Other), Chain, Src);
DCI.AddToWorklist(Swap.getNode());
Chain = Swap.getValue(1);
SDValue StoreOps[] = { Chain, Swap, Base };
SDValue Store = DAG.getMemIntrinsicNode(PPCISD::STXVD2X, dl,
DAG.getVTList(MVT::Other),
StoreOps, VecTy, MMO);
DCI.AddToWorklist(Store.getNode());
return Store;
}
// Handle DAG combine for STORE (FP_TO_INT F).
SDValue PPCTargetLowering::combineStoreFPToInt(SDNode *N,
DAGCombinerInfo &DCI) const {
SelectionDAG &DAG = DCI.DAG;
SDLoc dl(N);
unsigned Opcode = N->getOperand(1).getOpcode();
assert((Opcode == ISD::FP_TO_SINT || Opcode == ISD::FP_TO_UINT)
&& "Not a FP_TO_INT Instruction!");
SDValue Val = N->getOperand(1).getOperand(0);
EVT Op1VT = N->getOperand(1).getValueType();
EVT ResVT = Val.getValueType();
if (!isTypeLegal(ResVT))
return SDValue();
// Only perform combine for conversion to i64/i32 or power9 i16/i8.
bool ValidTypeForStoreFltAsInt =
(Op1VT == MVT::i32 || Op1VT == MVT::i64 ||
(Subtarget.hasP9Vector() && (Op1VT == MVT::i16 || Op1VT == MVT::i8)));
if (ResVT == MVT::f128 && !Subtarget.hasP9Vector())
return SDValue();
if (ResVT == MVT::ppcf128 || !Subtarget.hasP8Vector() ||
cast<StoreSDNode>(N)->isTruncatingStore() || !ValidTypeForStoreFltAsInt)
return SDValue();
// Extend f32 values to f64
if (ResVT.getScalarSizeInBits() == 32) {
Val = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Val);
DCI.AddToWorklist(Val.getNode());
}
// Set signed or unsigned conversion opcode.
unsigned ConvOpcode = (Opcode == ISD::FP_TO_SINT) ?
PPCISD::FP_TO_SINT_IN_VSR :
PPCISD::FP_TO_UINT_IN_VSR;
Val = DAG.getNode(ConvOpcode,
dl, ResVT == MVT::f128 ? MVT::f128 : MVT::f64, Val);
DCI.AddToWorklist(Val.getNode());
// Set number of bytes being converted.
unsigned ByteSize = Op1VT.getScalarSizeInBits() / 8;
SDValue Ops[] = { N->getOperand(0), Val, N->getOperand(2),
DAG.getIntPtrConstant(ByteSize, dl, false),
DAG.getValueType(Op1VT) };
Val = DAG.getMemIntrinsicNode(PPCISD::ST_VSR_SCAL_INT, dl,
DAG.getVTList(MVT::Other), Ops,
cast<StoreSDNode>(N)->getMemoryVT(),
cast<StoreSDNode>(N)->getMemOperand());
DCI.AddToWorklist(Val.getNode());
return Val;
}
static bool isAlternatingShuffMask(const ArrayRef<int> &Mask, int NumElts) {
// Check that the source of the element keeps flipping
// (i.e. Mask[i] < NumElts -> Mask[i+i] >= NumElts).
bool PrevElemFromFirstVec = Mask[0] < NumElts;
for (int i = 1, e = Mask.size(); i < e; i++) {
if (PrevElemFromFirstVec && Mask[i] < NumElts)
return false;
if (!PrevElemFromFirstVec && Mask[i] >= NumElts)
return false;
PrevElemFromFirstVec = !PrevElemFromFirstVec;
}
return true;
}
static bool isSplatBV(SDValue Op) {
if (Op.getOpcode() != ISD::BUILD_VECTOR)
return false;
SDValue FirstOp;
// Find first non-undef input.
for (int i = 0, e = Op.getNumOperands(); i < e; i++) {
FirstOp = Op.getOperand(i);
if (!FirstOp.isUndef())
break;
}
// All inputs are undef or the same as the first non-undef input.
for (int i = 1, e = Op.getNumOperands(); i < e; i++)
if (Op.getOperand(i) != FirstOp && !Op.getOperand(i).isUndef())
return false;
return true;
}
static SDValue isScalarToVec(SDValue Op) {
if (Op.getOpcode() == ISD::SCALAR_TO_VECTOR)
return Op;
if (Op.getOpcode() != ISD::BITCAST)
return SDValue();
Op = Op.getOperand(0);
if (Op.getOpcode() == ISD::SCALAR_TO_VECTOR)
return Op;
return SDValue();
}
// Fix up the shuffle mask to account for the fact that the result of
// scalar_to_vector is not in lane zero. This just takes all values in
// the ranges specified by the min/max indices and adds the number of
// elements required to ensure each element comes from the respective
// position in the valid lane.
// On little endian, that's just the corresponding element in the other
// half of the vector. On big endian, it is in the same half but right
// justified rather than left justified in that half.
static void fixupShuffleMaskForPermutedSToV(SmallVectorImpl<int> &ShuffV,
int LHSMaxIdx, int RHSMinIdx,
int RHSMaxIdx, int HalfVec,
unsigned ValidLaneWidth,
const PPCSubtarget &Subtarget) {
for (int i = 0, e = ShuffV.size(); i < e; i++) {
int Idx = ShuffV[i];
if ((Idx >= 0 && Idx < LHSMaxIdx) || (Idx >= RHSMinIdx && Idx < RHSMaxIdx))
ShuffV[i] +=
Subtarget.isLittleEndian() ? HalfVec : HalfVec - ValidLaneWidth;
}
}
// Replace a SCALAR_TO_VECTOR with a SCALAR_TO_VECTOR_PERMUTED except if
// the original is:
// (<n x Ty> (scalar_to_vector (Ty (extract_elt <n x Ty> %a, C))))
// In such a case, just change the shuffle mask to extract the element
// from the permuted index.
static SDValue getSToVPermuted(SDValue OrigSToV, SelectionDAG &DAG,
const PPCSubtarget &Subtarget) {
SDLoc dl(OrigSToV);
EVT VT = OrigSToV.getValueType();
assert(OrigSToV.getOpcode() == ISD::SCALAR_TO_VECTOR &&
"Expecting a SCALAR_TO_VECTOR here");
SDValue Input = OrigSToV.getOperand(0);
if (Input.getOpcode() == ISD::EXTRACT_VECTOR_ELT) {
ConstantSDNode *Idx = dyn_cast<ConstantSDNode>(Input.getOperand(1));
SDValue OrigVector = Input.getOperand(0);
// Can't handle non-const element indices or different vector types
// for the input to the extract and the output of the scalar_to_vector.
if (Idx && VT == OrigVector.getValueType()) {
unsigned NumElts = VT.getVectorNumElements();
assert(
NumElts > 1 &&
"Cannot produce a permuted scalar_to_vector for one element vector");
SmallVector<int, 16> NewMask(NumElts, -1);
unsigned ResultInElt = NumElts / 2;
ResultInElt -= Subtarget.isLittleEndian() ? 0 : 1;
NewMask[ResultInElt] = Idx->getZExtValue();
return DAG.getVectorShuffle(VT, dl, OrigVector, OrigVector, NewMask);
}
}
return DAG.getNode(PPCISD::SCALAR_TO_VECTOR_PERMUTED, dl, VT,
OrigSToV.getOperand(0));
}
// On little endian subtargets, combine shuffles such as:
// vector_shuffle<16,1,17,3,18,5,19,7,20,9,21,11,22,13,23,15>, <zero>, %b
// into:
// vector_shuffle<16,0,17,1,18,2,19,3,20,4,21,5,22,6,23,7>, <zero>, %b
// because the latter can be matched to a single instruction merge.
// Furthermore, SCALAR_TO_VECTOR on little endian always involves a permute
// to put the value into element zero. Adjust the shuffle mask so that the
// vector can remain in permuted form (to prevent a swap prior to a shuffle).
// On big endian targets, this is still useful for SCALAR_TO_VECTOR
// nodes with elements smaller than doubleword because all the ways
// of getting scalar data into a vector register put the value in the
// rightmost element of the left half of the vector.
SDValue PPCTargetLowering::combineVectorShuffle(ShuffleVectorSDNode *SVN,
SelectionDAG &DAG) const {
SDValue LHS = SVN->getOperand(0);
SDValue RHS = SVN->getOperand(1);
auto Mask = SVN->getMask();
int NumElts = LHS.getValueType().getVectorNumElements();
SDValue Res(SVN, 0);
SDLoc dl(SVN);
bool IsLittleEndian = Subtarget.isLittleEndian();
// On big endian targets this is only useful for subtargets with direct moves.
// On little endian targets it would be useful for all subtargets with VSX.
// However adding special handling for LE subtargets without direct moves
// would be wasted effort since the minimum arch for LE is ISA 2.07 (Power8)
// which includes direct moves.
if (!Subtarget.hasDirectMove())
return Res;
// If this is not a shuffle of a shuffle and the first element comes from
// the second vector, canonicalize to the commuted form. This will make it
// more likely to match one of the single instruction patterns.
if (Mask[0] >= NumElts && LHS.getOpcode() != ISD::VECTOR_SHUFFLE &&
RHS.getOpcode() != ISD::VECTOR_SHUFFLE) {
std::swap(LHS, RHS);
Res = DAG.getCommutedVectorShuffle(*SVN);
Mask = cast<ShuffleVectorSDNode>(Res)->getMask();
}
// Adjust the shuffle mask if either input vector comes from a
// SCALAR_TO_VECTOR and keep the respective input vector in permuted
// form (to prevent the need for a swap).
SmallVector<int, 16> ShuffV(Mask.begin(), Mask.end());
SDValue SToVLHS = isScalarToVec(LHS);
SDValue SToVRHS = isScalarToVec(RHS);
if (SToVLHS || SToVRHS) {
int NumEltsIn = SToVLHS ? SToVLHS.getValueType().getVectorNumElements()
: SToVRHS.getValueType().getVectorNumElements();
int NumEltsOut = ShuffV.size();
// The width of the "valid lane" (i.e. the lane that contains the value that
// is vectorized) needs to be expressed in terms of the number of elements
// of the shuffle. It is thereby the ratio of the values before and after
// any bitcast.
unsigned ValidLaneWidth =
SToVLHS ? SToVLHS.getValueType().getScalarSizeInBits() /
LHS.getValueType().getScalarSizeInBits()
: SToVRHS.getValueType().getScalarSizeInBits() /
RHS.getValueType().getScalarSizeInBits();
// Initially assume that neither input is permuted. These will be adjusted
// accordingly if either input is.
int LHSMaxIdx = -1;
int RHSMinIdx = -1;
int RHSMaxIdx = -1;
int HalfVec = LHS.getValueType().getVectorNumElements() / 2;
// Get the permuted scalar to vector nodes for the source(s) that come from
// ISD::SCALAR_TO_VECTOR.
// On big endian systems, this only makes sense for element sizes smaller
// than 64 bits since for 64-bit elements, all instructions already put
// the value into element zero. Since scalar size of LHS and RHS may differ
// after isScalarToVec, this should be checked using their own sizes.
if (SToVLHS) {
if (!IsLittleEndian && SToVLHS.getValueType().getScalarSizeInBits() >= 64)
return Res;
// Set up the values for the shuffle vector fixup.
LHSMaxIdx = NumEltsOut / NumEltsIn;
SToVLHS = getSToVPermuted(SToVLHS, DAG, Subtarget);
if (SToVLHS.getValueType() != LHS.getValueType())
SToVLHS = DAG.getBitcast(LHS.getValueType(), SToVLHS);
LHS = SToVLHS;
}
if (SToVRHS) {
if (!IsLittleEndian && SToVRHS.getValueType().getScalarSizeInBits() >= 64)
return Res;
RHSMinIdx = NumEltsOut;
RHSMaxIdx = NumEltsOut / NumEltsIn + RHSMinIdx;
SToVRHS = getSToVPermuted(SToVRHS, DAG, Subtarget);
if (SToVRHS.getValueType() != RHS.getValueType())
SToVRHS = DAG.getBitcast(RHS.getValueType(), SToVRHS);
RHS = SToVRHS;
}
// Fix up the shuffle mask to reflect where the desired element actually is.
// The minimum and maximum indices that correspond to element zero for both
// the LHS and RHS are computed and will control which shuffle mask entries
// are to be changed. For example, if the RHS is permuted, any shuffle mask
// entries in the range [RHSMinIdx,RHSMaxIdx) will be adjusted.
fixupShuffleMaskForPermutedSToV(ShuffV, LHSMaxIdx, RHSMinIdx, RHSMaxIdx,
HalfVec, ValidLaneWidth, Subtarget);
Res = DAG.getVectorShuffle(SVN->getValueType(0), dl, LHS, RHS, ShuffV);
// We may have simplified away the shuffle. We won't be able to do anything
// further with it here.
if (!isa<ShuffleVectorSDNode>(Res))
return Res;
Mask = cast<ShuffleVectorSDNode>(Res)->getMask();
}
SDValue TheSplat = IsLittleEndian ? RHS : LHS;
// The common case after we commuted the shuffle is that the RHS is a splat
// and we have elements coming in from the splat at indices that are not
// conducive to using a merge.
// Example:
// vector_shuffle<0,17,1,19,2,21,3,23,4,25,5,27,6,29,7,31> t1, <zero>
if (!isSplatBV(TheSplat))
return Res;
// We are looking for a mask such that all even elements are from
// one vector and all odd elements from the other.
if (!isAlternatingShuffMask(Mask, NumElts))
return Res;
// Adjust the mask so we are pulling in the same index from the splat
// as the index from the interesting vector in consecutive elements.
if (IsLittleEndian) {
// Example (even elements from first vector):
// vector_shuffle<0,16,1,17,2,18,3,19,4,20,5,21,6,22,7,23> t1, <zero>
if (Mask[0] < NumElts)
for (int i = 1, e = Mask.size(); i < e; i += 2)
ShuffV[i] = (ShuffV[i - 1] + NumElts);
// Example (odd elements from first vector):
// vector_shuffle<16,0,17,1,18,2,19,3,20,4,21,5,22,6,23,7> t1, <zero>
else
for (int i = 0, e = Mask.size(); i < e; i += 2)
ShuffV[i] = (ShuffV[i + 1] + NumElts);
} else {
// Example (even elements from first vector):
// vector_shuffle<0,16,1,17,2,18,3,19,4,20,5,21,6,22,7,23> <zero>, t1
if (Mask[0] < NumElts)
for (int i = 0, e = Mask.size(); i < e; i += 2)
ShuffV[i] = ShuffV[i + 1] - NumElts;
// Example (odd elements from first vector):
// vector_shuffle<16,0,17,1,18,2,19,3,20,4,21,5,22,6,23,7> <zero>, t1
else
for (int i = 1, e = Mask.size(); i < e; i += 2)
ShuffV[i] = ShuffV[i - 1] - NumElts;
}
// If the RHS has undefs, we need to remove them since we may have created
// a shuffle that adds those instead of the splat value.
SDValue SplatVal =
cast<BuildVectorSDNode>(TheSplat.getNode())->getSplatValue();
TheSplat = DAG.getSplatBuildVector(TheSplat.getValueType(), dl, SplatVal);
if (IsLittleEndian)
RHS = TheSplat;
else
LHS = TheSplat;
return DAG.getVectorShuffle(SVN->getValueType(0), dl, LHS, RHS, ShuffV);
}
SDValue PPCTargetLowering::combineVReverseMemOP(ShuffleVectorSDNode *SVN,
LSBaseSDNode *LSBase,
DAGCombinerInfo &DCI) const {
assert((ISD::isNormalLoad(LSBase) || ISD::isNormalStore(LSBase)) &&
"Not a reverse memop pattern!");
auto IsElementReverse = [](const ShuffleVectorSDNode *SVN) -> bool {
auto Mask = SVN->getMask();
int i = 0;
auto I = Mask.rbegin();
auto E = Mask.rend();
for (; I != E; ++I) {
if (*I != i)
return false;
i++;
}
return true;
};
SelectionDAG &DAG = DCI.DAG;
EVT VT = SVN->getValueType(0);
if (!isTypeLegal(VT) || !Subtarget.isLittleEndian() || !Subtarget.hasVSX())
return SDValue();
// Before P9, we have PPCVSXSwapRemoval pass to hack the element order.
// See comment in PPCVSXSwapRemoval.cpp.
// It is conflict with PPCVSXSwapRemoval opt. So we don't do it.
if (!Subtarget.hasP9Vector())
return SDValue();
if(!IsElementReverse(SVN))
return SDValue();
if (LSBase->getOpcode() == ISD::LOAD) {
// If the load return value 0 has more than one user except the
// shufflevector instruction, it is not profitable to replace the
// shufflevector with a reverse load.
for (SDNode::use_iterator UI = LSBase->use_begin(), UE = LSBase->use_end();
UI != UE; ++UI)
if (UI.getUse().getResNo() == 0 && UI->getOpcode() != ISD::VECTOR_SHUFFLE)
return SDValue();
SDLoc dl(LSBase);
SDValue LoadOps[] = {LSBase->getChain(), LSBase->getBasePtr()};
return DAG.getMemIntrinsicNode(
PPCISD::LOAD_VEC_BE, dl, DAG.getVTList(VT, MVT::Other), LoadOps,
LSBase->getMemoryVT(), LSBase->getMemOperand());
}
if (LSBase->getOpcode() == ISD::STORE) {
// If there are other uses of the shuffle, the swap cannot be avoided.
// Forcing the use of an X-Form (since swapped stores only have
// X-Forms) without removing the swap is unprofitable.
if (!SVN->hasOneUse())
return SDValue();
SDLoc dl(LSBase);
SDValue StoreOps[] = {LSBase->getChain(), SVN->getOperand(0),
LSBase->getBasePtr()};
return DAG.getMemIntrinsicNode(
PPCISD::STORE_VEC_BE, dl, DAG.getVTList(MVT::Other), StoreOps,
LSBase->getMemoryVT(), LSBase->getMemOperand());
}
llvm_unreachable("Expected a load or store node here");
}
SDValue PPCTargetLowering::PerformDAGCombine(SDNode *N,
DAGCombinerInfo &DCI) const {
SelectionDAG &DAG = DCI.DAG;
SDLoc dl(N);
switch (N->getOpcode()) {
default: break;
case ISD::ADD:
return combineADD(N, DCI);
case ISD::SHL:
return combineSHL(N, DCI);
case ISD::SRA:
return combineSRA(N, DCI);
case ISD::SRL:
return combineSRL(N, DCI);
case ISD::MUL:
return combineMUL(N, DCI);
case ISD::FMA:
case PPCISD::FNMSUB:
return combineFMALike(N, DCI);
case PPCISD::SHL:
if (isNullConstant(N->getOperand(0))) // 0 << V -> 0.
return N->getOperand(0);
break;
case PPCISD::SRL:
if (isNullConstant(N->getOperand(0))) // 0 >>u V -> 0.
return N->getOperand(0);
break;
case PPCISD::SRA:
if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(N->getOperand(0))) {
if (C->isZero() || // 0 >>s V -> 0.
C->isAllOnes()) // -1 >>s V -> -1.
return N->getOperand(0);
}
break;
case ISD::SIGN_EXTEND:
case ISD::ZERO_EXTEND:
case ISD::ANY_EXTEND:
return DAGCombineExtBoolTrunc(N, DCI);
case ISD::TRUNCATE:
return combineTRUNCATE(N, DCI);
case ISD::SETCC:
if (SDValue CSCC = combineSetCC(N, DCI))
return CSCC;
LLVM_FALLTHROUGH;
case ISD::SELECT_CC:
return DAGCombineTruncBoolExt(N, DCI);
case ISD::SINT_TO_FP:
case ISD::UINT_TO_FP:
return combineFPToIntToFP(N, DCI);
case ISD::VECTOR_SHUFFLE:
if (ISD::isNormalLoad(N->getOperand(0).getNode())) {
LSBaseSDNode* LSBase = cast<LSBaseSDNode>(N->getOperand(0));
return combineVReverseMemOP(cast<ShuffleVectorSDNode>(N), LSBase, DCI);
}
return combineVectorShuffle(cast<ShuffleVectorSDNode>(N), DCI.DAG);
case ISD::STORE: {
EVT Op1VT = N->getOperand(1).getValueType();
unsigned Opcode = N->getOperand(1).getOpcode();
if (Opcode == ISD::FP_TO_SINT || Opcode == ISD::FP_TO_UINT) {
SDValue Val= combineStoreFPToInt(N, DCI);
if (Val)
return Val;
}
if (Opcode == ISD::VECTOR_SHUFFLE && ISD::isNormalStore(N)) {
ShuffleVectorSDNode *SVN = cast<ShuffleVectorSDNode>(N->getOperand(1));
SDValue Val= combineVReverseMemOP(SVN, cast<LSBaseSDNode>(N), DCI);
if (Val)
return Val;
}
// Turn STORE (BSWAP) -> sthbrx/stwbrx.
if (cast<StoreSDNode>(N)->isUnindexed() && Opcode == ISD::BSWAP &&
N->getOperand(1).getNode()->hasOneUse() &&
(Op1VT == MVT::i32 || Op1VT == MVT::i16 ||
(Subtarget.hasLDBRX() && Subtarget.isPPC64() && Op1VT == MVT::i64))) {
// STBRX can only handle simple types and it makes no sense to store less
// two bytes in byte-reversed order.
EVT mVT = cast<StoreSDNode>(N)->getMemoryVT();
if (mVT.isExtended() || mVT.getSizeInBits() < 16)
break;
SDValue BSwapOp = N->getOperand(1).getOperand(0);
// Do an any-extend to 32-bits if this is a half-word input.
if (BSwapOp.getValueType() == MVT::i16)
BSwapOp = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, BSwapOp);
// If the type of BSWAP operand is wider than stored memory width
// it need to be shifted to the right side before STBRX.
if (Op1VT.bitsGT(mVT)) {
int Shift = Op1VT.getSizeInBits() - mVT.getSizeInBits();
BSwapOp = DAG.getNode(ISD::SRL, dl, Op1VT, BSwapOp,
DAG.getConstant(Shift, dl, MVT::i32));
// Need to truncate if this is a bswap of i64 stored as i32/i16.
if (Op1VT == MVT::i64)
BSwapOp = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, BSwapOp);
}
SDValue Ops[] = {
N->getOperand(0), BSwapOp, N->getOperand(2), DAG.getValueType(mVT)
};
return
DAG.getMemIntrinsicNode(PPCISD::STBRX, dl, DAG.getVTList(MVT::Other),
Ops, cast<StoreSDNode>(N)->getMemoryVT(),
cast<StoreSDNode>(N)->getMemOperand());
}
// STORE Constant:i32<0> -> STORE<trunc to i32> Constant:i64<0>
// So it can increase the chance of CSE constant construction.
if (Subtarget.isPPC64() && !DCI.isBeforeLegalize() &&
isa<ConstantSDNode>(N->getOperand(1)) && Op1VT == MVT::i32) {
// Need to sign-extended to 64-bits to handle negative values.
EVT MemVT = cast<StoreSDNode>(N)->getMemoryVT();
uint64_t Val64 = SignExtend64(N->getConstantOperandVal(1),
MemVT.getSizeInBits());
SDValue Const64 = DAG.getConstant(Val64, dl, MVT::i64);
// DAG.getTruncStore() can't be used here because it doesn't accept
// the general (base + offset) addressing mode.
// So we use UpdateNodeOperands and setTruncatingStore instead.
DAG.UpdateNodeOperands(N, N->getOperand(0), Const64, N->getOperand(2),
N->getOperand(3));
cast<StoreSDNode>(N)->setTruncatingStore(true);
return SDValue(N, 0);
}
// For little endian, VSX stores require generating xxswapd/lxvd2x.
// Not needed on ISA 3.0 based CPUs since we have a non-permuting store.
if (Op1VT.isSimple()) {
MVT StoreVT = Op1VT.getSimpleVT();
if (Subtarget.needsSwapsForVSXMemOps() &&
(StoreVT == MVT::v2f64 || StoreVT == MVT::v2i64 ||
StoreVT == MVT::v4f32 || StoreVT == MVT::v4i32))
return expandVSXStoreForLE(N, DCI);
}
break;
}
case ISD::LOAD: {
LoadSDNode *LD = cast<LoadSDNode>(N);
EVT VT = LD->getValueType(0);
// For little endian, VSX loads require generating lxvd2x/xxswapd.
// Not needed on ISA 3.0 based CPUs since we have a non-permuting load.
if (VT.isSimple()) {
MVT LoadVT = VT.getSimpleVT();
if (Subtarget.needsSwapsForVSXMemOps() &&
(LoadVT == MVT::v2f64 || LoadVT == MVT::v2i64 ||
LoadVT == MVT::v4f32 || LoadVT == MVT::v4i32))
return expandVSXLoadForLE(N, DCI);
}
// We sometimes end up with a 64-bit integer load, from which we extract
// two single-precision floating-point numbers. This happens with
// std::complex<float>, and other similar structures, because of the way we
// canonicalize structure copies. However, if we lack direct moves,
// then the final bitcasts from the extracted integer values to the
// floating-point numbers turn into store/load pairs. Even with direct moves,
// just loading the two floating-point numbers is likely better.
auto ReplaceTwoFloatLoad = [&]() {
if (VT != MVT::i64)
return false;
if (LD->getExtensionType() != ISD::NON_EXTLOAD ||
LD->isVolatile())
return false;
// We're looking for a sequence like this:
// t13: i64,ch = load<LD8[%ref.tmp]> t0, t6, undef:i64
// t16: i64 = srl t13, Constant:i32<32>
// t17: i32 = truncate t16
// t18: f32 = bitcast t17
// t19: i32 = truncate t13
// t20: f32 = bitcast t19
if (!LD->hasNUsesOfValue(2, 0))
return false;
auto UI = LD->use_begin();
while (UI.getUse().getResNo() != 0) ++UI;
SDNode *Trunc = *UI++;
while (UI.getUse().getResNo() != 0) ++UI;
SDNode *RightShift = *UI;
if (Trunc->getOpcode() != ISD::TRUNCATE)
std::swap(Trunc, RightShift);
if (Trunc->getOpcode() != ISD::TRUNCATE ||
Trunc->getValueType(0) != MVT::i32 ||
!Trunc->hasOneUse())
return false;
if (RightShift->getOpcode() != ISD::SRL ||
!isa<ConstantSDNode>(RightShift->getOperand(1)) ||
RightShift->getConstantOperandVal(1) != 32 ||
!RightShift->hasOneUse())
return false;
SDNode *Trunc2 = *RightShift->use_begin();
if (Trunc2->getOpcode() != ISD::TRUNCATE ||
Trunc2->getValueType(0) != MVT::i32 ||
!Trunc2->hasOneUse())
return false;
SDNode *Bitcast = *Trunc->use_begin();
SDNode *Bitcast2 = *Trunc2->use_begin();
if (Bitcast->getOpcode() != ISD::BITCAST ||
Bitcast->getValueType(0) != MVT::f32)
return false;
if (Bitcast2->getOpcode() != ISD::BITCAST ||
Bitcast2->getValueType(0) != MVT::f32)
return false;
if (Subtarget.isLittleEndian())
std::swap(Bitcast, Bitcast2);
// Bitcast has the second float (in memory-layout order) and Bitcast2
// has the first one.
SDValue BasePtr = LD->getBasePtr();
if (LD->isIndexed()) {
assert(LD->getAddressingMode() == ISD::PRE_INC &&
"Non-pre-inc AM on PPC?");
BasePtr =
DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(), BasePtr,
LD->getOffset());
}
auto MMOFlags =
LD->getMemOperand()->getFlags() & ~MachineMemOperand::MOVolatile;
SDValue FloatLoad = DAG.getLoad(MVT::f32, dl, LD->getChain(), BasePtr,
LD->getPointerInfo(), LD->getAlignment(),
MMOFlags, LD->getAAInfo());
SDValue AddPtr =
DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(),
BasePtr, DAG.getIntPtrConstant(4, dl));
SDValue FloatLoad2 = DAG.getLoad(
MVT::f32, dl, SDValue(FloatLoad.getNode(), 1), AddPtr,
LD->getPointerInfo().getWithOffset(4),
MinAlign(LD->getAlignment(), 4), MMOFlags, LD->getAAInfo());
if (LD->isIndexed()) {
// Note that DAGCombine should re-form any pre-increment load(s) from
// what is produced here if that makes sense.
DAG.ReplaceAllUsesOfValueWith(SDValue(LD, 1), BasePtr);
}
DCI.CombineTo(Bitcast2, FloatLoad);
DCI.CombineTo(Bitcast, FloatLoad2);
DAG.ReplaceAllUsesOfValueWith(SDValue(LD, LD->isIndexed() ? 2 : 1),
SDValue(FloatLoad2.getNode(), 1));
return true;
};
if (ReplaceTwoFloatLoad())
return SDValue(N, 0);
EVT MemVT = LD->getMemoryVT();
Type *Ty = MemVT.getTypeForEVT(*DAG.getContext());
Align ABIAlignment = DAG.getDataLayout().getABITypeAlign(Ty);
if (LD->isUnindexed() && VT.isVector() &&
((Subtarget.hasAltivec() && ISD::isNON_EXTLoad(N) &&
// P8 and later hardware should just use LOAD.
!Subtarget.hasP8Vector() &&
(VT == MVT::v16i8 || VT == MVT::v8i16 || VT == MVT::v4i32 ||
VT == MVT::v4f32))) &&
LD->getAlign() < ABIAlignment) {
// This is a type-legal unaligned Altivec load.
SDValue Chain = LD->getChain();
SDValue Ptr = LD->getBasePtr();
bool isLittleEndian = Subtarget.isLittleEndian();
// This implements the loading of unaligned vectors as described in
// the venerable Apple Velocity Engine overview. Specifically:
// https://developer.apple.com/hardwaredrivers/ve/alignment.html
// https://developer.apple.com/hardwaredrivers/ve/code_optimization.html
//
// The general idea is to expand a sequence of one or more unaligned
// loads into an alignment-based permutation-control instruction (lvsl
// or lvsr), a series of regular vector loads (which always truncate
// their input address to an aligned address), and a series of
// permutations. The results of these permutations are the requested
// loaded values. The trick is that the last "extra" load is not taken
// from the address you might suspect (sizeof(vector) bytes after the
// last requested load), but rather sizeof(vector) - 1 bytes after the
// last requested vector. The point of this is to avoid a page fault if
// the base address happened to be aligned. This works because if the
// base address is aligned, then adding less than a full vector length
// will cause the last vector in the sequence to be (re)loaded.
// Otherwise, the next vector will be fetched as you might suspect was
// necessary.
// We might be able to reuse the permutation generation from
// a different base address offset from this one by an aligned amount.
// The INTRINSIC_WO_CHAIN DAG combine will attempt to perform this
// optimization later.
Intrinsic::ID Intr, IntrLD, IntrPerm;
MVT PermCntlTy, PermTy, LDTy;
Intr = isLittleEndian ? Intrinsic::ppc_altivec_lvsr
: Intrinsic::ppc_altivec_lvsl;
IntrLD = Intrinsic::ppc_altivec_lvx;
IntrPerm = Intrinsic::ppc_altivec_vperm;
PermCntlTy = MVT::v16i8;
PermTy = MVT::v4i32;
LDTy = MVT::v4i32;
SDValue PermCntl = BuildIntrinsicOp(Intr, Ptr, DAG, dl, PermCntlTy);
// Create the new MMO for the new base load. It is like the original MMO,
// but represents an area in memory almost twice the vector size centered
// on the original address. If the address is unaligned, we might start
// reading up to (sizeof(vector)-1) bytes below the address of the
// original unaligned load.
MachineFunction &MF = DAG.getMachineFunction();
MachineMemOperand *BaseMMO =
MF.getMachineMemOperand(LD->getMemOperand(),
-(long)MemVT.getStoreSize()+1,
2*MemVT.getStoreSize()-1);
// Create the new base load.
SDValue LDXIntID =
DAG.getTargetConstant(IntrLD, dl, getPointerTy(MF.getDataLayout()));
SDValue BaseLoadOps[] = { Chain, LDXIntID, Ptr };
SDValue BaseLoad =
DAG.getMemIntrinsicNode(ISD::INTRINSIC_W_CHAIN, dl,
DAG.getVTList(PermTy, MVT::Other),
BaseLoadOps, LDTy, BaseMMO);
// Note that the value of IncOffset (which is provided to the next
// load's pointer info offset value, and thus used to calculate the
// alignment), and the value of IncValue (which is actually used to
// increment the pointer value) are different! This is because we
// require the next load to appear to be aligned, even though it
// is actually offset from the base pointer by a lesser amount.
int IncOffset = VT.getSizeInBits() / 8;
int IncValue = IncOffset;
// Walk (both up and down) the chain looking for another load at the real
// (aligned) offset (the alignment of the other load does not matter in
// this case). If found, then do not use the offset reduction trick, as
// that will prevent the loads from being later combined (as they would
// otherwise be duplicates).
if (!findConsecutiveLoad(LD, DAG))
--IncValue;
SDValue Increment =
DAG.getConstant(IncValue, dl, getPointerTy(MF.getDataLayout()));
Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
MachineMemOperand *ExtraMMO =
MF.getMachineMemOperand(LD->getMemOperand(),
1, 2*MemVT.getStoreSize()-1);
SDValue ExtraLoadOps[] = { Chain, LDXIntID, Ptr };
SDValue ExtraLoad =
DAG.getMemIntrinsicNode(ISD::INTRINSIC_W_CHAIN, dl,
DAG.getVTList(PermTy, MVT::Other),
ExtraLoadOps, LDTy, ExtraMMO);
SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
BaseLoad.getValue(1), ExtraLoad.getValue(1));
// Because vperm has a big-endian bias, we must reverse the order
// of the input vectors and complement the permute control vector
// when generating little endian code. We have already handled the
// latter by using lvsr instead of lvsl, so just reverse BaseLoad
// and ExtraLoad here.
SDValue Perm;
if (isLittleEndian)
Perm = BuildIntrinsicOp(IntrPerm,
ExtraLoad, BaseLoad, PermCntl, DAG, dl);
else
Perm = BuildIntrinsicOp(IntrPerm,
BaseLoad, ExtraLoad, PermCntl, DAG, dl);
if (VT != PermTy)
Perm = Subtarget.hasAltivec()
? DAG.getNode(ISD::BITCAST, dl, VT, Perm)
: DAG.getNode(ISD::FP_ROUND, dl, VT, Perm,
DAG.getTargetConstant(1, dl, MVT::i64));
// second argument is 1 because this rounding
// is always exact.
// The output of the permutation is our loaded result, the TokenFactor is
// our new chain.
DCI.CombineTo(N, Perm, TF);
return SDValue(N, 0);
}
}
break;
case ISD::INTRINSIC_WO_CHAIN: {
bool isLittleEndian = Subtarget.isLittleEndian();
unsigned IID = cast<ConstantSDNode>(N->getOperand(0))->getZExtValue();
Intrinsic::ID Intr = (isLittleEndian ? Intrinsic::ppc_altivec_lvsr
: Intrinsic::ppc_altivec_lvsl);
if (IID == Intr && N->getOperand(1)->getOpcode() == ISD::ADD) {
SDValue Add = N->getOperand(1);
int Bits = 4 /* 16 byte alignment */;
if (DAG.MaskedValueIsZero(Add->getOperand(1),
APInt::getAllOnes(Bits /* alignment */)
.zext(Add.getScalarValueSizeInBits()))) {
SDNode *BasePtr = Add->getOperand(0).getNode();
for (SDNode *U : BasePtr->uses()) {
if (U->getOpcode() == ISD::INTRINSIC_WO_CHAIN &&
cast<ConstantSDNode>(U->getOperand(0))->getZExtValue() == IID) {
// We've found another LVSL/LVSR, and this address is an aligned
// multiple of that one. The results will be the same, so use the
// one we've just found instead.
return SDValue(U, 0);
}
}
}
if (isa<ConstantSDNode>(Add->getOperand(1))) {
SDNode *BasePtr = Add->getOperand(0).getNode();
for (SDNode *U : BasePtr->uses()) {
if (U->getOpcode() == ISD::ADD &&
isa<ConstantSDNode>(U->getOperand(1)) &&
(cast<ConstantSDNode>(Add->getOperand(1))->getZExtValue() -
cast<ConstantSDNode>(U->getOperand(1))->getZExtValue()) %
(1ULL << Bits) ==
0) {
SDNode *OtherAdd = U;
for (SDNode *V : OtherAdd->uses()) {
if (V->getOpcode() == ISD::INTRINSIC_WO_CHAIN &&
cast<ConstantSDNode>(V->getOperand(0))->getZExtValue() ==
IID) {
return SDValue(V, 0);
}
}
}
}
}
}
// Combine vmaxsw/h/b(a, a's negation) to abs(a)
// Expose the vabsduw/h/b opportunity for down stream
if (!DCI.isAfterLegalizeDAG() && Subtarget.hasP9Altivec() &&
(IID == Intrinsic::ppc_altivec_vmaxsw ||
IID == Intrinsic::ppc_altivec_vmaxsh ||
IID == Intrinsic::ppc_altivec_vmaxsb)) {
SDValue V1 = N->getOperand(1);
SDValue V2 = N->getOperand(2);
if ((V1.getSimpleValueType() == MVT::v4i32 ||
V1.getSimpleValueType() == MVT::v8i16 ||
V1.getSimpleValueType() == MVT::v16i8) &&
V1.getSimpleValueType() == V2.getSimpleValueType()) {
// (0-a, a)
if (V1.getOpcode() == ISD::SUB &&
ISD::isBuildVectorAllZeros(V1.getOperand(0).getNode()) &&
V1.getOperand(1) == V2) {
return DAG.getNode(ISD::ABS, dl, V2.getValueType(), V2);
}
// (a, 0-a)
if (V2.getOpcode() == ISD::SUB &&
ISD::isBuildVectorAllZeros(V2.getOperand(0).getNode()) &&
V2.getOperand(1) == V1) {
return DAG.getNode(ISD::ABS, dl, V1.getValueType(), V1);
}
// (x-y, y-x)
if (V1.getOpcode() == ISD::SUB && V2.getOpcode() == ISD::SUB &&
V1.getOperand(0) == V2.getOperand(1) &&
V1.getOperand(1) == V2.getOperand(0)) {
return DAG.getNode(ISD::ABS, dl, V1.getValueType(), V1);
}
}
}
}
break;
case ISD::INTRINSIC_W_CHAIN:
// For little endian, VSX loads require generating lxvd2x/xxswapd.
// Not needed on ISA 3.0 based CPUs since we have a non-permuting load.
if (Subtarget.needsSwapsForVSXMemOps()) {
switch (cast<ConstantSDNode>(N->getOperand(1))->getZExtValue()) {
default:
break;
case Intrinsic::ppc_vsx_lxvw4x:
case Intrinsic::ppc_vsx_lxvd2x:
return expandVSXLoadForLE(N, DCI);
}
}
break;
case ISD::INTRINSIC_VOID:
// For little endian, VSX stores require generating xxswapd/stxvd2x.
// Not needed on ISA 3.0 based CPUs since we have a non-permuting store.
if (Subtarget.needsSwapsForVSXMemOps()) {
switch (cast<ConstantSDNode>(N->getOperand(1))->getZExtValue()) {
default:
break;
case Intrinsic::ppc_vsx_stxvw4x:
case Intrinsic::ppc_vsx_stxvd2x:
return expandVSXStoreForLE(N, DCI);
}
}
break;
case ISD::BSWAP: {
// Turn BSWAP (LOAD) -> lhbrx/lwbrx.
// For subtargets without LDBRX, we can still do better than the default
// expansion even for 64-bit BSWAP (LOAD).
bool Is64BitBswapOn64BitTgt =
Subtarget.isPPC64() && N->getValueType(0) == MVT::i64;
bool IsSingleUseNormalLd = ISD::isNormalLoad(N->getOperand(0).getNode()) &&
N->getOperand(0).hasOneUse();
if (IsSingleUseNormalLd &&
(N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i16 ||
(Subtarget.hasLDBRX() && Is64BitBswapOn64BitTgt))) {
SDValue Load = N->getOperand(0);
LoadSDNode *LD = cast<LoadSDNode>(Load);
// Create the byte-swapping load.
SDValue Ops[] = {
LD->getChain(), // Chain
LD->getBasePtr(), // Ptr
DAG.getValueType(N->getValueType(0)) // VT
};
SDValue BSLoad =
DAG.getMemIntrinsicNode(PPCISD::LBRX, dl,
DAG.getVTList(N->getValueType(0) == MVT::i64 ?
MVT::i64 : MVT::i32, MVT::Other),
Ops, LD->getMemoryVT(), LD->getMemOperand());
// If this is an i16 load, insert the truncate.
SDValue ResVal = BSLoad;
if (N->getValueType(0) == MVT::i16)
ResVal = DAG.getNode(ISD::TRUNCATE, dl, MVT::i16, BSLoad);
// First, combine the bswap away. This makes the value produced by the
// load dead.
DCI.CombineTo(N, ResVal);
// Next, combine the load away, we give it a bogus result value but a real
// chain result. The result value is dead because the bswap is dead.
DCI.CombineTo(Load.getNode(), ResVal, BSLoad.getValue(1));
// Return N so it doesn't get rechecked!
return SDValue(N, 0);
}
// Convert this to two 32-bit bswap loads and a BUILD_PAIR. Do this only
// before legalization so that the BUILD_PAIR is handled correctly.
if (!DCI.isBeforeLegalize() || !Is64BitBswapOn64BitTgt ||
!IsSingleUseNormalLd)
return SDValue();
LoadSDNode *LD = cast<LoadSDNode>(N->getOperand(0));
// Can't split volatile or atomic loads.
if (!LD->isSimple())
return SDValue();
SDValue BasePtr = LD->getBasePtr();
SDValue Lo = DAG.getLoad(MVT::i32, dl, LD->getChain(), BasePtr,
LD->getPointerInfo(), LD->getAlignment());
Lo = DAG.getNode(ISD::BSWAP, dl, MVT::i32, Lo);
BasePtr = DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(), BasePtr,
DAG.getIntPtrConstant(4, dl));
MachineMemOperand *NewMMO = DAG.getMachineFunction().getMachineMemOperand(
LD->getMemOperand(), 4, 4);
SDValue Hi = DAG.getLoad(MVT::i32, dl, LD->getChain(), BasePtr, NewMMO);
Hi = DAG.getNode(ISD::BSWAP, dl, MVT::i32, Hi);
SDValue Res;
if (Subtarget.isLittleEndian())
Res = DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Hi, Lo);
else
Res = DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Lo, Hi);
SDValue TF =
DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
Hi.getOperand(0).getValue(1), Lo.getOperand(0).getValue(1));
DAG.ReplaceAllUsesOfValueWith(SDValue(LD, 1), TF);
return Res;
}
case PPCISD::VCMP:
// If a VCMP_rec node already exists with exactly the same operands as this
// node, use its result instead of this node (VCMP_rec computes both a CR6
// and a normal output).
//
if (!N->getOperand(0).hasOneUse() &&
!N->getOperand(1).hasOneUse() &&
!N->getOperand(2).hasOneUse()) {
// Scan all of the users of the LHS, looking for VCMP_rec's that match.
SDNode *VCMPrecNode = nullptr;
SDNode *LHSN = N->getOperand(0).getNode();
for (SDNode::use_iterator UI = LHSN->use_begin(), E = LHSN->use_end();
UI != E; ++UI)
if (UI->getOpcode() == PPCISD::VCMP_rec &&
UI->getOperand(1) == N->getOperand(1) &&
UI->getOperand(2) == N->getOperand(2) &&
UI->getOperand(0) == N->getOperand(0)) {
VCMPrecNode = *UI;
break;
}
// If there is no VCMP_rec node, or if the flag value has a single use,
// don't transform this.
if (!VCMPrecNode || VCMPrecNode->hasNUsesOfValue(0, 1))
break;
// Look at the (necessarily single) use of the flag value. If it has a
// chain, this transformation is more complex. Note that multiple things
// could use the value result, which we should ignore.
SDNode *FlagUser = nullptr;
for (SDNode::use_iterator UI = VCMPrecNode->use_begin();
FlagUser == nullptr; ++UI) {
assert(UI != VCMPrecNode->use_end() && "Didn't find user!");
SDNode *User = *UI;
for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i) {
if (User->getOperand(i) == SDValue(VCMPrecNode, 1)) {
FlagUser = User;
break;
}
}
}
// If the user is a MFOCRF instruction, we know this is safe.
// Otherwise we give up for right now.
if (FlagUser->getOpcode() == PPCISD::MFOCRF)
return SDValue(VCMPrecNode, 0);
}
break;
case ISD::BRCOND: {
SDValue Cond = N->getOperand(1);
SDValue Target = N->getOperand(2);
if (Cond.getOpcode() == ISD::INTRINSIC_W_CHAIN &&
cast<ConstantSDNode>(Cond.getOperand(1))->getZExtValue() ==
Intrinsic::loop_decrement) {
// We now need to make the intrinsic dead (it cannot be instruction
// selected).
DAG.ReplaceAllUsesOfValueWith(Cond.getValue(1), Cond.getOperand(0));
assert(Cond.getNode()->hasOneUse() &&
"Counter decrement has more than one use");
return DAG.getNode(PPCISD::BDNZ, dl, MVT::Other,
N->getOperand(0), Target);
}
}
break;
case ISD::BR_CC: {
// If this is a branch on an altivec predicate comparison, lower this so
// that we don't have to do a MFOCRF: instead, branch directly on CR6. This
// lowering is done pre-legalize, because the legalizer lowers the predicate
// compare down to code that is difficult to reassemble.
ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(1))->get();
SDValue LHS = N->getOperand(2), RHS = N->getOperand(3);
// Sometimes the promoted value of the intrinsic is ANDed by some non-zero
// value. If so, pass-through the AND to get to the intrinsic.
if (LHS.getOpcode() == ISD::AND &&
LHS.getOperand(0).getOpcode() == ISD::INTRINSIC_W_CHAIN &&
cast<ConstantSDNode>(LHS.getOperand(0).getOperand(1))->getZExtValue() ==
Intrinsic::loop_decrement &&
isa<ConstantSDNode>(LHS.getOperand(1)) &&
!isNullConstant(LHS.getOperand(1)))
LHS = LHS.getOperand(0);
if (LHS.getOpcode() == ISD::INTRINSIC_W_CHAIN &&
cast<ConstantSDNode>(LHS.getOperand(1))->getZExtValue() ==
Intrinsic::loop_decrement &&
isa<ConstantSDNode>(RHS)) {
assert((CC == ISD::SETEQ || CC == ISD::SETNE) &&
"Counter decrement comparison is not EQ or NE");
unsigned Val = cast<ConstantSDNode>(RHS)->getZExtValue();
bool isBDNZ = (CC == ISD::SETEQ && Val) ||
(CC == ISD::SETNE && !Val);
// We now need to make the intrinsic dead (it cannot be instruction
// selected).
DAG.ReplaceAllUsesOfValueWith(LHS.getValue(1), LHS.getOperand(0));
assert(LHS.getNode()->hasOneUse() &&
"Counter decrement has more than one use");
return DAG.getNode(isBDNZ ? PPCISD::BDNZ : PPCISD::BDZ, dl, MVT::Other,
N->getOperand(0), N->getOperand(4));
}
int CompareOpc;
bool isDot;
if (LHS.getOpcode() == ISD::INTRINSIC_WO_CHAIN &&
isa<ConstantSDNode>(RHS) && (CC == ISD::SETEQ || CC == ISD::SETNE) &&
getVectorCompareInfo(LHS, CompareOpc, isDot, Subtarget)) {
assert(isDot && "Can't compare against a vector result!");
// If this is a comparison against something other than 0/1, then we know
// that the condition is never/always true.
unsigned Val = cast<ConstantSDNode>(RHS)->getZExtValue();
if (Val != 0 && Val != 1) {
if (CC == ISD::SETEQ) // Cond never true, remove branch.
return N->getOperand(0);
// Always !=, turn it into an unconditional branch.
return DAG.getNode(ISD::BR, dl, MVT::Other,
N->getOperand(0), N->getOperand(4));
}
bool BranchOnWhenPredTrue = (CC == ISD::SETEQ) ^ (Val == 0);
// Create the PPCISD altivec 'dot' comparison node.
SDValue Ops[] = {
LHS.getOperand(2), // LHS of compare
LHS.getOperand(3), // RHS of compare
DAG.getConstant(CompareOpc, dl, MVT::i32)
};
EVT VTs[] = { LHS.getOperand(2).getValueType(), MVT::Glue };
SDValue CompNode = DAG.getNode(PPCISD::VCMP_rec, dl, VTs, Ops);
// Unpack the result based on how the target uses it.
PPC::Predicate CompOpc;
switch (cast<ConstantSDNode>(LHS.getOperand(1))->getZExtValue()) {
default: // Can't happen, don't crash on invalid number though.
case 0: // Branch on the value of the EQ bit of CR6.
CompOpc = BranchOnWhenPredTrue ? PPC::PRED_EQ : PPC::PRED_NE;
break;
case 1: // Branch on the inverted value of the EQ bit of CR6.
CompOpc = BranchOnWhenPredTrue ? PPC::PRED_NE : PPC::PRED_EQ;
break;
case 2: // Branch on the value of the LT bit of CR6.
CompOpc = BranchOnWhenPredTrue ? PPC::PRED_LT : PPC::PRED_GE;
break;
case 3: // Branch on the inverted value of the LT bit of CR6.
CompOpc = BranchOnWhenPredTrue ? PPC::PRED_GE : PPC::PRED_LT;
break;
}
return DAG.getNode(PPCISD::COND_BRANCH, dl, MVT::Other, N->getOperand(0),
DAG.getConstant(CompOpc, dl, MVT::i32),
DAG.getRegister(PPC::CR6, MVT::i32),
N->getOperand(4), CompNode.getValue(1));
}
break;
}
case ISD::BUILD_VECTOR:
return DAGCombineBuildVector(N, DCI);
case ISD::ABS:
return combineABS(N, DCI);
case ISD::VSELECT:
return combineVSelect(N, DCI);
}
return SDValue();
}
SDValue
PPCTargetLowering::BuildSDIVPow2(SDNode *N, const APInt &Divisor,
SelectionDAG &DAG,
SmallVectorImpl<SDNode *> &Created) const {
// fold (sdiv X, pow2)
EVT VT = N->getValueType(0);
if (VT == MVT::i64 && !Subtarget.isPPC64())
return SDValue();
if ((VT != MVT::i32 && VT != MVT::i64) ||
!(Divisor.isPowerOf2() || Divisor.isNegatedPowerOf2()))
return SDValue();
SDLoc DL(N);
SDValue N0 = N->getOperand(0);
bool IsNegPow2 = Divisor.isNegatedPowerOf2();
unsigned Lg2 = (IsNegPow2 ? -Divisor : Divisor).countTrailingZeros();
SDValue ShiftAmt = DAG.getConstant(Lg2, DL, VT);
SDValue Op = DAG.getNode(PPCISD::SRA_ADDZE, DL, VT, N0, ShiftAmt);
Created.push_back(Op.getNode());
if (IsNegPow2) {
Op = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), Op);
Created.push_back(Op.getNode());
}
return Op;
}
//===----------------------------------------------------------------------===//
// Inline Assembly Support
//===----------------------------------------------------------------------===//
void PPCTargetLowering::computeKnownBitsForTargetNode(const SDValue Op,
KnownBits &Known,
const APInt &DemandedElts,
const SelectionDAG &DAG,
unsigned Depth) const {
Known.resetAll();
switch (Op.getOpcode()) {
default: break;
case PPCISD::LBRX: {
// lhbrx is known to have the top bits cleared out.
if (cast<VTSDNode>(Op.getOperand(2))->getVT() == MVT::i16)
Known.Zero = 0xFFFF0000;
break;
}
case ISD::INTRINSIC_WO_CHAIN: {
switch (cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue()) {
default: break;
case Intrinsic::ppc_altivec_vcmpbfp_p:
case Intrinsic::ppc_altivec_vcmpeqfp_p:
case Intrinsic::ppc_altivec_vcmpequb_p:
case Intrinsic::ppc_altivec_vcmpequh_p:
case Intrinsic::ppc_altivec_vcmpequw_p:
case Intrinsic::ppc_altivec_vcmpequd_p:
case Intrinsic::ppc_altivec_vcmpequq_p:
case Intrinsic::ppc_altivec_vcmpgefp_p:
case Intrinsic::ppc_altivec_vcmpgtfp_p:
case Intrinsic::ppc_altivec_vcmpgtsb_p:
case Intrinsic::ppc_altivec_vcmpgtsh_p:
case Intrinsic::ppc_altivec_vcmpgtsw_p:
case Intrinsic::ppc_altivec_vcmpgtsd_p:
case Intrinsic::ppc_altivec_vcmpgtsq_p:
case Intrinsic::ppc_altivec_vcmpgtub_p:
case Intrinsic::ppc_altivec_vcmpgtuh_p:
case Intrinsic::ppc_altivec_vcmpgtuw_p:
case Intrinsic::ppc_altivec_vcmpgtud_p:
case Intrinsic::ppc_altivec_vcmpgtuq_p:
Known.Zero = ~1U; // All bits but the low one are known to be zero.
break;
}
break;
}
case ISD::INTRINSIC_W_CHAIN: {
switch (cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue()) {
default:
break;
case Intrinsic::ppc_load2r:
// Top bits are cleared for load2r (which is the same as lhbrx).
Known.Zero = 0xFFFF0000;
break;
}
break;
}
}
}
Align PPCTargetLowering::getPrefLoopAlignment(MachineLoop *ML) const {
switch (Subtarget.getCPUDirective()) {
default: break;
case PPC::DIR_970:
case PPC::DIR_PWR4:
case PPC::DIR_PWR5:
case PPC::DIR_PWR5X:
case PPC::DIR_PWR6:
case PPC::DIR_PWR6X:
case PPC::DIR_PWR7:
case PPC::DIR_PWR8:
case PPC::DIR_PWR9:
case PPC::DIR_PWR10:
case PPC::DIR_PWR_FUTURE: {
if (!ML)
break;
if (!DisableInnermostLoopAlign32) {
// If the nested loop is an innermost loop, prefer to a 32-byte alignment,
// so that we can decrease cache misses and branch-prediction misses.
// Actual alignment of the loop will depend on the hotness check and other
// logic in alignBlocks.
if (ML->getLoopDepth() > 1 && ML->getSubLoops().empty())
return Align(32);
}
const PPCInstrInfo *TII = Subtarget.getInstrInfo();
// For small loops (between 5 and 8 instructions), align to a 32-byte
// boundary so that the entire loop fits in one instruction-cache line.
uint64_t LoopSize = 0;
for (auto I = ML->block_begin(), IE = ML->block_end(); I != IE; ++I)
for (auto J = (*I)->begin(), JE = (*I)->end(); J != JE; ++J) {
LoopSize += TII->getInstSizeInBytes(*J);
if (LoopSize > 32)
break;
}
if (LoopSize > 16 && LoopSize <= 32)
return Align(32);
break;
}
}
return TargetLowering::getPrefLoopAlignment(ML);
}
/// getConstraintType - Given a constraint, return the type of
/// constraint it is for this target.
PPCTargetLowering::ConstraintType
PPCTargetLowering::getConstraintType(StringRef Constraint) const {
if (Constraint.size() == 1) {
switch (Constraint[0]) {
default: break;
case 'b':
case 'r':
case 'f':
case 'd':
case 'v':
case 'y':
return C_RegisterClass;
case 'Z':
// FIXME: While Z does indicate a memory constraint, it specifically
// indicates an r+r address (used in conjunction with the 'y' modifier
// in the replacement string). Currently, we're forcing the base
// register to be r0 in the asm printer (which is interpreted as zero)
// and forming the complete address in the second register. This is
// suboptimal.
return C_Memory;
}
} else if (Constraint == "wc") { // individual CR bits.
return C_RegisterClass;
} else if (Constraint == "wa" || Constraint == "wd" ||
Constraint == "wf" || Constraint == "ws" ||
Constraint == "wi" || Constraint == "ww") {
return C_RegisterClass; // VSX registers.
}
return TargetLowering::getConstraintType(Constraint);
}
/// Examine constraint type and operand type and determine a weight value.
/// This object must already have been set up with the operand type
/// and the current alternative constraint selected.
TargetLowering::ConstraintWeight
PPCTargetLowering::getSingleConstraintMatchWeight(
AsmOperandInfo &info, const char *constraint) const {
ConstraintWeight weight = CW_Invalid;
Value *CallOperandVal = info.CallOperandVal;
// If we don't have a value, we can't do a match,
// but allow it at the lowest weight.
if (!CallOperandVal)
return CW_Default;
Type *type = CallOperandVal->getType();
// Look at the constraint type.
if (StringRef(constraint) == "wc" && type->isIntegerTy(1))
return CW_Register; // an individual CR bit.
else if ((StringRef(constraint) == "wa" ||
StringRef(constraint) == "wd" ||
StringRef(constraint) == "wf") &&
type->isVectorTy())
return CW_Register;
else if (StringRef(constraint) == "wi" && type->isIntegerTy(64))
return CW_Register; // just hold 64-bit integers data.
else if (StringRef(constraint) == "ws" && type->isDoubleTy())
return CW_Register;
else if (StringRef(constraint) == "ww" && type->isFloatTy())
return CW_Register;
switch (*constraint) {
default:
weight = TargetLowering::getSingleConstraintMatchWeight(info, constraint);
break;
case 'b':
if (type->isIntegerTy())
weight = CW_Register;
break;
case 'f':
if (type->isFloatTy())
weight = CW_Register;
break;
case 'd':
if (type->isDoubleTy())
weight = CW_Register;
break;
case 'v':
if (type->isVectorTy())
weight = CW_Register;
break;
case 'y':
weight = CW_Register;
break;
case 'Z':
weight = CW_Memory;
break;
}
return weight;
}
std::pair<unsigned, const TargetRegisterClass *>
PPCTargetLowering::getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI,
StringRef Constraint,
MVT VT) const {
if (Constraint.size() == 1) {
// GCC RS6000 Constraint Letters
switch (Constraint[0]) {
case 'b': // R1-R31
if (VT == MVT::i64 && Subtarget.isPPC64())
return std::make_pair(0U, &PPC::G8RC_NOX0RegClass);
return std::make_pair(0U, &PPC::GPRC_NOR0RegClass);
case 'r': // R0-R31
if (VT == MVT::i64 && Subtarget.isPPC64())
return std::make_pair(0U, &PPC::G8RCRegClass);
return std::make_pair(0U, &PPC::GPRCRegClass);
// 'd' and 'f' constraints are both defined to be "the floating point
// registers", where one is for 32-bit and the other for 64-bit. We don't
// really care overly much here so just give them all the same reg classes.
case 'd':
case 'f':
if (Subtarget.hasSPE()) {
if (VT == MVT::f32 || VT == MVT::i32)
return std::make_pair(0U, &PPC::GPRCRegClass);
if (VT == MVT::f64 || VT == MVT::i64)
return std::make_pair(0U, &PPC::SPERCRegClass);
} else {
if (VT == MVT::f32 || VT == MVT::i32)
return std::make_pair(0U, &PPC::F4RCRegClass);
if (VT == MVT::f64 || VT == MVT::i64)
return std::make_pair(0U, &PPC::F8RCRegClass);
}
break;
case 'v':
if (Subtarget.hasAltivec() && VT.isVector())
return std::make_pair(0U, &PPC::VRRCRegClass);
else if (Subtarget.hasVSX())
// Scalars in Altivec registers only make sense with VSX.
return std::make_pair(0U, &PPC::VFRCRegClass);
break;
case 'y': // crrc
return std::make_pair(0U, &PPC::CRRCRegClass);
}
} else if (Constraint == "wc" && Subtarget.useCRBits()) {
// An individual CR bit.
return std::make_pair(0U, &PPC::CRBITRCRegClass);
} else if ((Constraint == "wa" || Constraint == "wd" ||
Constraint == "wf" || Constraint == "wi") &&
Subtarget.hasVSX()) {
// A VSX register for either a scalar (FP) or vector. There is no
// support for single precision scalars on subtargets prior to Power8.
if (VT.isVector())
return std::make_pair(0U, &PPC::VSRCRegClass);
if (VT == MVT::f32 && Subtarget.hasP8Vector())
return std::make_pair(0U, &PPC::VSSRCRegClass);
return std::make_pair(0U, &PPC::VSFRCRegClass);
} else if ((Constraint == "ws" || Constraint == "ww") && Subtarget.hasVSX()) {
if (VT == MVT::f32 && Subtarget.hasP8Vector())
return std::make_pair(0U, &PPC::VSSRCRegClass);
else
return std::make_pair(0U, &PPC::VSFRCRegClass);
} else if (Constraint == "lr") {
if (VT == MVT::i64)
return std::make_pair(0U, &PPC::LR8RCRegClass);
else
return std::make_pair(0U, &PPC::LRRCRegClass);
}
// Handle special cases of physical registers that are not properly handled
// by the base class.
if (Constraint[0] == '{' && Constraint[Constraint.size() - 1] == '}') {
// If we name a VSX register, we can't defer to the base class because it
// will not recognize the correct register (their names will be VSL{0-31}
// and V{0-31} so they won't match). So we match them here.
if (Constraint.size() > 3 && Constraint[1] == 'v' && Constraint[2] == 's') {
int VSNum = atoi(Constraint.data() + 3);
assert(VSNum >= 0 && VSNum <= 63 &&
"Attempted to access a vsr out of range");
if (VSNum < 32)
return std::make_pair(PPC::VSL0 + VSNum, &PPC::VSRCRegClass);
return std::make_pair(PPC::V0 + VSNum - 32, &PPC::VSRCRegClass);
}
// For float registers, we can't defer to the base class as it will match
// the SPILLTOVSRRC class.
if (Constraint.size() > 3 && Constraint[1] == 'f') {
int RegNum = atoi(Constraint.data() + 2);
if (RegNum > 31 || RegNum < 0)
report_fatal_error("Invalid floating point register number");
if (VT == MVT::f32 || VT == MVT::i32)
return Subtarget.hasSPE()
? std::make_pair(PPC::R0 + RegNum, &PPC::GPRCRegClass)
: std::make_pair(PPC::F0 + RegNum, &PPC::F4RCRegClass);
if (VT == MVT::f64 || VT == MVT::i64)
return Subtarget.hasSPE()
? std::make_pair(PPC::S0 + RegNum, &PPC::SPERCRegClass)
: std::make_pair(PPC::F0 + RegNum, &PPC::F8RCRegClass);
}
}
std::pair<unsigned, const TargetRegisterClass *> R =
TargetLowering::getRegForInlineAsmConstraint(TRI, Constraint, VT);
// r[0-9]+ are used, on PPC64, to refer to the corresponding 64-bit registers
// (which we call X[0-9]+). If a 64-bit value has been requested, and a
// 32-bit GPR has been selected, then 'upgrade' it to the 64-bit parent
// register.
// FIXME: If TargetLowering::getRegForInlineAsmConstraint could somehow use
// the AsmName field from *RegisterInfo.td, then this would not be necessary.
if (R.first && VT == MVT::i64 && Subtarget.isPPC64() &&
PPC::GPRCRegClass.contains(R.first))
return std::make_pair(TRI->getMatchingSuperReg(R.first,
PPC::sub_32, &PPC::G8RCRegClass),
&PPC::G8RCRegClass);
// GCC accepts 'cc' as an alias for 'cr0', and we need to do the same.
if (!R.second && StringRef("{cc}").equals_insensitive(Constraint)) {
R.first = PPC::CR0;
R.second = &PPC::CRRCRegClass;
}
// FIXME: This warning should ideally be emitted in the front end.
const auto &TM = getTargetMachine();
if (Subtarget.isAIXABI() && !TM.getAIXExtendedAltivecABI()) {
if (((R.first >= PPC::V20 && R.first <= PPC::V31) ||
(R.first >= PPC::VF20 && R.first <= PPC::VF31)) &&
(R.second == &PPC::VSRCRegClass || R.second == &PPC::VSFRCRegClass))
errs() << "warning: vector registers 20 to 32 are reserved in the "
"default AIX AltiVec ABI and cannot be used\n";
}
return R;
}
/// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
/// vector. If it is invalid, don't add anything to Ops.
void PPCTargetLowering::LowerAsmOperandForConstraint(SDValue Op,
std::string &Constraint,
std::vector<SDValue>&Ops,
SelectionDAG &DAG) const {
SDValue Result;
// Only support length 1 constraints.
if (Constraint.length() > 1) return;
char Letter = Constraint[0];
switch (Letter) {
default: break;
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P': {
ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Op);
if (!CST) return; // Must be an immediate to match.
SDLoc dl(Op);
int64_t Value = CST->getSExtValue();
EVT TCVT = MVT::i64; // All constants taken to be 64 bits so that negative
// numbers are printed as such.
switch (Letter) {
default: llvm_unreachable("Unknown constraint letter!");
case 'I': // "I" is a signed 16-bit constant.
if (isInt<16>(Value))
Result = DAG.getTargetConstant(Value, dl, TCVT);
break;
case 'J': // "J" is a constant with only the high-order 16 bits nonzero.
if (isShiftedUInt<16, 16>(Value))
Result = DAG.getTargetConstant(Value, dl, TCVT);
break;
case 'L': // "L" is a signed 16-bit constant shifted left 16 bits.
if (isShiftedInt<16, 16>(Value))
Result = DAG.getTargetConstant(Value, dl, TCVT);
break;
case 'K': // "K" is a constant with only the low-order 16 bits nonzero.
if (isUInt<16>(Value))
Result = DAG.getTargetConstant(Value, dl, TCVT);
break;
case 'M': // "M" is a constant that is greater than 31.
if (Value > 31)
Result = DAG.getTargetConstant(Value, dl, TCVT);
break;
case 'N': // "N" is a positive constant that is an exact power of two.
if (Value > 0 && isPowerOf2_64(Value))
Result = DAG.getTargetConstant(Value, dl, TCVT);
break;
case 'O': // "O" is the constant zero.
if (Value == 0)
Result = DAG.getTargetConstant(Value, dl, TCVT);
break;
case 'P': // "P" is a constant whose negation is a signed 16-bit constant.
if (isInt<16>(-Value))
Result = DAG.getTargetConstant(Value, dl, TCVT);
break;
}
break;
}
}
if (Result.getNode()) {
Ops.push_back(Result);
return;
}
// Handle standard constraint letters.
TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG);
}
// isLegalAddressingMode - Return true if the addressing mode represented
// by AM is legal for this target, for a load/store of the specified type.
bool PPCTargetLowering::isLegalAddressingMode(const DataLayout &DL,
const AddrMode &AM, Type *Ty,
unsigned AS,
Instruction *I) const {
// Vector type r+i form is supported since power9 as DQ form. We don't check
// the offset matching DQ form requirement(off % 16 == 0), because on PowerPC,
// imm form is preferred and the offset can be adjusted to use imm form later
// in pass PPCLoopInstrFormPrep. Also in LSR, for one LSRUse, it uses min and
// max offset to check legal addressing mode, we should be a little aggressive
// to contain other offsets for that LSRUse.
if (Ty->isVectorTy() && AM.BaseOffs != 0 && !Subtarget.hasP9Vector())
return false;
// PPC allows a sign-extended 16-bit immediate field.
if (AM.BaseOffs <= -(1LL << 16) || AM.BaseOffs >= (1LL << 16)-1)
return false;
// No global is ever allowed as a base.
if (AM.BaseGV)
return false;
// PPC only support r+r,
switch (AM.Scale) {
case 0: // "r+i" or just "i", depending on HasBaseReg.
break;
case 1:
if (AM.HasBaseReg && AM.BaseOffs) // "r+r+i" is not allowed.
return false;
// Otherwise we have r+r or r+i.
break;
case 2:
if (AM.HasBaseReg || AM.BaseOffs) // 2*r+r or 2*r+i is not allowed.
return false;
// Allow 2*r as r+r.
break;
default:
// No other scales are supported.
return false;
}
return true;
}
SDValue PPCTargetLowering::LowerRETURNADDR(SDValue Op,
SelectionDAG &DAG) const {
MachineFunction &MF = DAG.getMachineFunction();
MachineFrameInfo &MFI = MF.getFrameInfo();
MFI.setReturnAddressIsTaken(true);
if (verifyReturnAddressArgumentIsConstant(Op, DAG))
return SDValue();
SDLoc dl(Op);
unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
// Make sure the function does not optimize away the store of the RA to
// the stack.
PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
FuncInfo->setLRStoreRequired();
bool isPPC64 = Subtarget.isPPC64();
auto PtrVT = getPointerTy(MF.getDataLayout());
if (Depth > 0) {
// The link register (return address) is saved in the caller's frame
// not the callee's stack frame. So we must get the caller's frame
// address and load the return address at the LR offset from there.
SDValue FrameAddr =
DAG.getLoad(Op.getValueType(), dl, DAG.getEntryNode(),
LowerFRAMEADDR(Op, DAG), MachinePointerInfo());
SDValue Offset =
DAG.getConstant(Subtarget.getFrameLowering()->getReturnSaveOffset(), dl,
isPPC64 ? MVT::i64 : MVT::i32);
return DAG.getLoad(PtrVT, dl, DAG.getEntryNode(),
DAG.getNode(ISD::ADD, dl, PtrVT, FrameAddr, Offset),
MachinePointerInfo());
}
// Just load the return address off the stack.
SDValue RetAddrFI = getReturnAddrFrameIndex(DAG);
return DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), RetAddrFI,
MachinePointerInfo());
}
SDValue PPCTargetLowering::LowerFRAMEADDR(SDValue Op,
SelectionDAG &DAG) const {
SDLoc dl(Op);
unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
MachineFunction &MF = DAG.getMachineFunction();
MachineFrameInfo &MFI = MF.getFrameInfo();
MFI.setFrameAddressIsTaken(true);
EVT PtrVT = getPointerTy(MF.getDataLayout());
bool isPPC64 = PtrVT == MVT::i64;
// Naked functions never have a frame pointer, and so we use r1. For all
// other functions, this decision must be delayed until during PEI.
unsigned FrameReg;
if (MF.getFunction().hasFnAttribute(Attribute::Naked))
FrameReg = isPPC64 ? PPC::X1 : PPC::R1;
else
FrameReg = isPPC64 ? PPC::FP8 : PPC::FP;
SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg,
PtrVT);
while (Depth--)
FrameAddr = DAG.getLoad(Op.getValueType(), dl, DAG.getEntryNode(),
FrameAddr, MachinePointerInfo());
return FrameAddr;
}
// FIXME? Maybe this could be a TableGen attribute on some registers and
// this table could be generated automatically from RegInfo.
Register PPCTargetLowering::getRegisterByName(const char* RegName, LLT VT,
const MachineFunction &MF) const {
bool isPPC64 = Subtarget.isPPC64();
bool is64Bit = isPPC64 && VT == LLT::scalar(64);
if (!is64Bit && VT != LLT::scalar(32))
report_fatal_error("Invalid register global variable type");
Register Reg = StringSwitch<Register>(RegName)
.Case("r1", is64Bit ? PPC::X1 : PPC::R1)
.Case("r2", isPPC64 ? Register() : PPC::R2)
.Case("r13", (is64Bit ? PPC::X13 : PPC::R13))
.Default(Register());
if (Reg)
return Reg;
report_fatal_error("Invalid register name global variable");
}
bool PPCTargetLowering::isAccessedAsGotIndirect(SDValue GA) const {
// 32-bit SVR4 ABI access everything as got-indirect.
if (Subtarget.is32BitELFABI())
return true;
// AIX accesses everything indirectly through the TOC, which is similar to
// the GOT.
if (Subtarget.isAIXABI())
return true;
CodeModel::Model CModel = getTargetMachine().getCodeModel();
// If it is small or large code model, module locals are accessed
// indirectly by loading their address from .toc/.got.
if (CModel == CodeModel::Small || CModel == CodeModel::Large)
return true;
// JumpTable and BlockAddress are accessed as got-indirect.
if (isa<JumpTableSDNode>(GA) || isa<BlockAddressSDNode>(GA))
return true;
if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(GA))
return Subtarget.isGVIndirectSymbol(G->getGlobal());
return false;
}
bool
PPCTargetLowering::isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const {
// The PowerPC target isn't yet aware of offsets.
return false;
}
bool PPCTargetLowering::getTgtMemIntrinsic(IntrinsicInfo &Info,
const CallInst &I,
MachineFunction &MF,
unsigned Intrinsic) const {
switch (Intrinsic) {
case Intrinsic::ppc_atomicrmw_xchg_i128:
case Intrinsic::ppc_atomicrmw_add_i128:
case Intrinsic::ppc_atomicrmw_sub_i128:
case Intrinsic::ppc_atomicrmw_nand_i128:
case Intrinsic::ppc_atomicrmw_and_i128:
case Intrinsic::ppc_atomicrmw_or_i128:
case Intrinsic::ppc_atomicrmw_xor_i128:
case Intrinsic::ppc_cmpxchg_i128:
Info.opc = ISD::INTRINSIC_W_CHAIN;
Info.memVT = MVT::i128;
Info.ptrVal = I.getArgOperand(0);
Info.offset = 0;
Info.align = Align(16);
Info.flags = MachineMemOperand::MOLoad | MachineMemOperand::MOStore |
MachineMemOperand::MOVolatile;
return true;
case Intrinsic::ppc_atomic_load_i128:
Info.opc = ISD::INTRINSIC_W_CHAIN;
Info.memVT = MVT::i128;
Info.ptrVal = I.getArgOperand(0);
Info.offset = 0;
Info.align = Align(16);
Info.flags = MachineMemOperand::MOLoad | MachineMemOperand::MOVolatile;
return true;
case Intrinsic::ppc_atomic_store_i128:
Info.opc = ISD::INTRINSIC_VOID;
Info.memVT = MVT::i128;
Info.ptrVal = I.getArgOperand(2);
Info.offset = 0;
Info.align = Align(16);
Info.flags = MachineMemOperand::MOStore | MachineMemOperand::MOVolatile;
return true;
case Intrinsic::ppc_altivec_lvx:
case Intrinsic::ppc_altivec_lvxl:
case Intrinsic::ppc_altivec_lvebx:
case Intrinsic::ppc_altivec_lvehx:
case Intrinsic::ppc_altivec_lvewx:
case Intrinsic::ppc_vsx_lxvd2x:
case Intrinsic::ppc_vsx_lxvw4x:
case Intrinsic::ppc_vsx_lxvd2x_be:
case Intrinsic::ppc_vsx_lxvw4x_be:
case Intrinsic::ppc_vsx_lxvl:
case Intrinsic::ppc_vsx_lxvll: {
EVT VT;
switch (Intrinsic) {
case Intrinsic::ppc_altivec_lvebx:
VT = MVT::i8;
break;
case Intrinsic::ppc_altivec_lvehx:
VT = MVT::i16;
break;
case Intrinsic::ppc_altivec_lvewx:
VT = MVT::i32;
break;
case Intrinsic::ppc_vsx_lxvd2x:
case Intrinsic::ppc_vsx_lxvd2x_be:
VT = MVT::v2f64;
break;
default:
VT = MVT::v4i32;
break;
}
Info.opc = ISD::INTRINSIC_W_CHAIN;
Info.memVT = VT;
Info.ptrVal = I.getArgOperand(0);
Info.offset = -VT.getStoreSize()+1;
Info.size = 2*VT.getStoreSize()-1;
Info.align = Align(1);
Info.flags = MachineMemOperand::MOLoad;
return true;
}
case Intrinsic::ppc_altivec_stvx:
case Intrinsic::ppc_altivec_stvxl:
case Intrinsic::ppc_altivec_stvebx:
case Intrinsic::ppc_altivec_stvehx:
case Intrinsic::ppc_altivec_stvewx:
case Intrinsic::ppc_vsx_stxvd2x:
case Intrinsic::ppc_vsx_stxvw4x:
case Intrinsic::ppc_vsx_stxvd2x_be:
case Intrinsic::ppc_vsx_stxvw4x_be:
case Intrinsic::ppc_vsx_stxvl:
case Intrinsic::ppc_vsx_stxvll: {
EVT VT;
switch (Intrinsic) {
case Intrinsic::ppc_altivec_stvebx:
VT = MVT::i8;
break;
case Intrinsic::ppc_altivec_stvehx:
VT = MVT::i16;
break;
case Intrinsic::ppc_altivec_stvewx:
VT = MVT::i32;
break;
case Intrinsic::ppc_vsx_stxvd2x:
case Intrinsic::ppc_vsx_stxvd2x_be:
VT = MVT::v2f64;
break;
default:
VT = MVT::v4i32;
break;
}
Info.opc = ISD::INTRINSIC_VOID;
Info.memVT = VT;
Info.ptrVal = I.getArgOperand(1);
Info.offset = -VT.getStoreSize()+1;
Info.size = 2*VT.getStoreSize()-1;
Info.align = Align(1);
Info.flags = MachineMemOperand::MOStore;
return true;
}
default:
break;
}
return false;
}
/// It returns EVT::Other if the type should be determined using generic
/// target-independent logic.
EVT PPCTargetLowering::getOptimalMemOpType(
const MemOp &Op, const AttributeList &FuncAttributes) const {
if (getTargetMachine().getOptLevel() != CodeGenOpt::None) {
// We should use Altivec/VSX loads and stores when available. For unaligned
// addresses, unaligned VSX loads are only fast starting with the P8.
if (Subtarget.hasAltivec() && Op.size() >= 16 &&
(Op.isAligned(Align(16)) ||
((Op.isMemset() && Subtarget.hasVSX()) || Subtarget.hasP8Vector())))
return MVT::v4i32;
}
if (Subtarget.isPPC64()) {
return MVT::i64;
}
return MVT::i32;
}
/// Returns true if it is beneficial to convert a load of a constant
/// to just the constant itself.
bool PPCTargetLowering::shouldConvertConstantLoadToIntImm(const APInt &Imm,
Type *Ty) const {
assert(Ty->isIntegerTy());
unsigned BitSize = Ty->getPrimitiveSizeInBits();
return !(BitSize == 0 || BitSize > 64);
}
bool PPCTargetLowering::isTruncateFree(Type *Ty1, Type *Ty2) const {
if (!Ty1->isIntegerTy() || !Ty2->isIntegerTy())
return false;
unsigned NumBits1 = Ty1->getPrimitiveSizeInBits();
unsigned NumBits2 = Ty2->getPrimitiveSizeInBits();
return NumBits1 == 64 && NumBits2 == 32;
}
bool PPCTargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
if (!VT1.isInteger() || !VT2.isInteger())
return false;
unsigned NumBits1 = VT1.getSizeInBits();
unsigned NumBits2 = VT2.getSizeInBits();
return NumBits1 == 64 && NumBits2 == 32;
}
bool PPCTargetLowering::isZExtFree(SDValue Val, EVT VT2) const {
// Generally speaking, zexts are not free, but they are free when they can be
// folded with other operations.
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(Val)) {
EVT MemVT = LD->getMemoryVT();
if ((MemVT == MVT::i1 || MemVT == MVT::i8 || MemVT == MVT::i16 ||
(Subtarget.isPPC64() && MemVT == MVT::i32)) &&
(LD->getExtensionType() == ISD::NON_EXTLOAD ||
LD->getExtensionType() == ISD::ZEXTLOAD))
return true;
}
// FIXME: Add other cases...
// - 32-bit shifts with a zext to i64
// - zext after ctlz, bswap, etc.
// - zext after and by a constant mask
return TargetLowering::isZExtFree(Val, VT2);
}
bool PPCTargetLowering::isFPExtFree(EVT DestVT, EVT SrcVT) const {
assert(DestVT.isFloatingPoint() && SrcVT.isFloatingPoint() &&
"invalid fpext types");
// Extending to float128 is not free.
if (DestVT == MVT::f128)
return false;
return true;
}
bool PPCTargetLowering::isLegalICmpImmediate(int64_t Imm) const {
return isInt<16>(Imm) || isUInt<16>(Imm);
}
bool PPCTargetLowering::isLegalAddImmediate(int64_t Imm) const {
return isInt<16>(Imm) || isUInt<16>(Imm);
}
bool PPCTargetLowering::allowsMisalignedMemoryAccesses(EVT VT, unsigned, Align,
MachineMemOperand::Flags,
bool *Fast) const {
if (DisablePPCUnaligned)
return false;
// PowerPC supports unaligned memory access for simple non-vector types.
// Although accessing unaligned addresses is not as efficient as accessing
// aligned addresses, it is generally more efficient than manual expansion,
// and generally only traps for software emulation when crossing page
// boundaries.
if (!VT.isSimple())
return false;
if (VT.isFloatingPoint() && !VT.isVector() &&
!Subtarget.allowsUnalignedFPAccess())
return false;
if (VT.getSimpleVT().isVector()) {
if (Subtarget.hasVSX()) {
if (VT != MVT::v2f64 && VT != MVT::v2i64 &&
VT != MVT::v4f32 && VT != MVT::v4i32)
return false;
} else {
return false;
}
}
if (VT == MVT::ppcf128)
return false;
if (Fast)
*Fast = true;
return true;
}
bool PPCTargetLowering::decomposeMulByConstant(LLVMContext &Context, EVT VT,
SDValue C) const {
// Check integral scalar types.
if (!VT.isScalarInteger())
return false;
if (auto *ConstNode = dyn_cast<ConstantSDNode>(C.getNode())) {
if (!ConstNode->getAPIntValue().isSignedIntN(64))
return false;
// This transformation will generate >= 2 operations. But the following
// cases will generate <= 2 instructions during ISEL. So exclude them.
// 1. If the constant multiplier fits 16 bits, it can be handled by one
// HW instruction, ie. MULLI
// 2. If the multiplier after shifted fits 16 bits, an extra shift
// instruction is needed than case 1, ie. MULLI and RLDICR
int64_t Imm = ConstNode->getSExtValue();
unsigned Shift = countTrailingZeros<uint64_t>(Imm);
Imm >>= Shift;
if (isInt<16>(Imm))
return false;
uint64_t UImm = static_cast<uint64_t>(Imm);
if (isPowerOf2_64(UImm + 1) || isPowerOf2_64(UImm - 1) ||
isPowerOf2_64(1 - UImm) || isPowerOf2_64(-1 - UImm))
return true;
}
return false;
}
bool PPCTargetLowering::isFMAFasterThanFMulAndFAdd(const MachineFunction &MF,
EVT VT) const {
return isFMAFasterThanFMulAndFAdd(
MF.getFunction(), VT.getTypeForEVT(MF.getFunction().getContext()));
}
bool PPCTargetLowering::isFMAFasterThanFMulAndFAdd(const Function &F,
Type *Ty) const {
switch (Ty->getScalarType()->getTypeID()) {
case Type::FloatTyID:
case Type::DoubleTyID:
return true;
case Type::FP128TyID:
return Subtarget.hasP9Vector();
default:
return false;
}
}
// FIXME: add more patterns which are not profitable to hoist.
bool PPCTargetLowering::isProfitableToHoist(Instruction *I) const {
if (!I->hasOneUse())
return true;
Instruction *User = I->user_back();
assert(User && "A single use instruction with no uses.");
switch (I->getOpcode()) {
case Instruction::FMul: {
// Don't break FMA, PowerPC prefers FMA.
if (User->getOpcode() != Instruction::FSub &&
User->getOpcode() != Instruction::FAdd)
return true;
const TargetOptions &Options = getTargetMachine().Options;
const Function *F = I->getFunction();
const DataLayout &DL = F->getParent()->getDataLayout();
Type *Ty = User->getOperand(0)->getType();
return !(
isFMAFasterThanFMulAndFAdd(*F, Ty) &&
isOperationLegalOrCustom(ISD::FMA, getValueType(DL, Ty)) &&
(Options.AllowFPOpFusion == FPOpFusion::Fast || Options.UnsafeFPMath));
}
case Instruction::Load: {
// Don't break "store (load float*)" pattern, this pattern will be combined
// to "store (load int32)" in later InstCombine pass. See function
// combineLoadToOperationType. On PowerPC, loading a float point takes more
// cycles than loading a 32 bit integer.
LoadInst *LI = cast<LoadInst>(I);
// For the loads that combineLoadToOperationType does nothing, like
// ordered load, it should be profitable to hoist them.
// For swifterror load, it can only be used for pointer to pointer type, so
// later type check should get rid of this case.
if (!LI->isUnordered())
return true;
if (User->getOpcode() != Instruction::Store)
return true;
if (I->getType()->getTypeID() != Type::FloatTyID)
return true;
return false;
}
default:
return true;
}
return true;
}
const MCPhysReg *
PPCTargetLowering::getScratchRegisters(CallingConv::ID) const {
// LR is a callee-save register, but we must treat it as clobbered by any call
// site. Hence we include LR in the scratch registers, which are in turn added
// as implicit-defs for stackmaps and patchpoints. The same reasoning applies
// to CTR, which is used by any indirect call.
static const MCPhysReg ScratchRegs[] = {
PPC::X12, PPC::LR8, PPC::CTR8, 0
};
return ScratchRegs;
}
Register PPCTargetLowering::getExceptionPointerRegister(
const Constant *PersonalityFn) const {
return Subtarget.isPPC64() ? PPC::X3 : PPC::R3;
}
Register PPCTargetLowering::getExceptionSelectorRegister(
const Constant *PersonalityFn) const {
return Subtarget.isPPC64() ? PPC::X4 : PPC::R4;
}
bool
PPCTargetLowering::shouldExpandBuildVectorWithShuffles(
EVT VT , unsigned DefinedValues) const {
if (VT == MVT::v2i64)
return Subtarget.hasDirectMove(); // Don't need stack ops with direct moves
if (Subtarget.hasVSX())
return true;
return TargetLowering::shouldExpandBuildVectorWithShuffles(VT, DefinedValues);
}
Sched::Preference PPCTargetLowering::getSchedulingPreference(SDNode *N) const {
if (DisableILPPref || Subtarget.enableMachineScheduler())
return TargetLowering::getSchedulingPreference(N);
return Sched::ILP;
}
// Create a fast isel object.
FastISel *
PPCTargetLowering::createFastISel(FunctionLoweringInfo &FuncInfo,
const TargetLibraryInfo *LibInfo) const {
return PPC::createFastISel(FuncInfo, LibInfo);
}
// 'Inverted' means the FMA opcode after negating one multiplicand.
// For example, (fma -a b c) = (fnmsub a b c)
static unsigned invertFMAOpcode(unsigned Opc) {
switch (Opc) {
default:
llvm_unreachable("Invalid FMA opcode for PowerPC!");
case ISD::FMA:
return PPCISD::FNMSUB;
case PPCISD::FNMSUB:
return ISD::FMA;
}
}
SDValue PPCTargetLowering::getNegatedExpression(SDValue Op, SelectionDAG &DAG,
bool LegalOps, bool OptForSize,
NegatibleCost &Cost,
unsigned Depth) const {
if (Depth > SelectionDAG::MaxRecursionDepth)
return SDValue();
unsigned Opc = Op.getOpcode();
EVT VT = Op.getValueType();
SDNodeFlags Flags = Op.getNode()->getFlags();
switch (Opc) {
case PPCISD::FNMSUB:
if (!Op.hasOneUse() || !isTypeLegal(VT))
break;
const TargetOptions &Options = getTargetMachine().Options;
SDValue N0 = Op.getOperand(0);
SDValue N1 = Op.getOperand(1);
SDValue N2 = Op.getOperand(2);
SDLoc Loc(Op);
NegatibleCost N2Cost = NegatibleCost::Expensive;
SDValue NegN2 =
getNegatedExpression(N2, DAG, LegalOps, OptForSize, N2Cost, Depth + 1);
if (!NegN2)
return SDValue();
// (fneg (fnmsub a b c)) => (fnmsub (fneg a) b (fneg c))
// (fneg (fnmsub a b c)) => (fnmsub a (fneg b) (fneg c))
// These transformations may change sign of zeroes. For example,
// -(-ab-(-c))=-0 while -(-(ab-c))=+0 when a=b=c=1.
if (Flags.hasNoSignedZeros() || Options.NoSignedZerosFPMath) {
// Try and choose the cheaper one to negate.
NegatibleCost N0Cost = NegatibleCost::Expensive;
SDValue NegN0 = getNegatedExpression(N0, DAG, LegalOps, OptForSize,
N0Cost, Depth + 1);
NegatibleCost N1Cost = NegatibleCost::Expensive;
SDValue NegN1 = getNegatedExpression(N1, DAG, LegalOps, OptForSize,
N1Cost, Depth + 1);
if (NegN0 && N0Cost <= N1Cost) {
Cost = std::min(N0Cost, N2Cost);
return DAG.getNode(Opc, Loc, VT, NegN0, N1, NegN2, Flags);
} else if (NegN1) {
Cost = std::min(N1Cost, N2Cost);
return DAG.getNode(Opc, Loc, VT, N0, NegN1, NegN2, Flags);
}
}
// (fneg (fnmsub a b c)) => (fma a b (fneg c))
if (isOperationLegal(ISD::FMA, VT)) {
Cost = N2Cost;
return DAG.getNode(ISD::FMA, Loc, VT, N0, N1, NegN2, Flags);
}
break;
}
return TargetLowering::getNegatedExpression(Op, DAG, LegalOps, OptForSize,
Cost, Depth);
}
// Override to enable LOAD_STACK_GUARD lowering on Linux.
bool PPCTargetLowering::useLoadStackGuardNode() const {
if (!Subtarget.isTargetLinux())
return TargetLowering::useLoadStackGuardNode();
return true;
}
// Override to disable global variable loading on Linux and insert AIX canary
// word declaration.
void PPCTargetLowering::insertSSPDeclarations(Module &M) const {
if (Subtarget.isAIXABI()) {
M.getOrInsertGlobal(AIXSSPCanaryWordName,
Type::getInt8PtrTy(M.getContext()));
return;
}
if (!Subtarget.isTargetLinux())
return TargetLowering::insertSSPDeclarations(M);
}
Value *PPCTargetLowering::getSDagStackGuard(const Module &M) const {
if (Subtarget.isAIXABI())
return M.getGlobalVariable(AIXSSPCanaryWordName);
return TargetLowering::getSDagStackGuard(M);
}
bool PPCTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
bool ForCodeSize) const {
if (!VT.isSimple() || !Subtarget.hasVSX())
return false;
switch(VT.getSimpleVT().SimpleTy) {
default:
// For FP types that are currently not supported by PPC backend, return
// false. Examples: f16, f80.
return false;
case MVT::f32:
case MVT::f64:
if (Subtarget.hasPrefixInstrs()) {
// we can materialize all immediatess via XXSPLTI32DX and XXSPLTIDP.
return true;
}
LLVM_FALLTHROUGH;
case MVT::ppcf128:
return Imm.isPosZero();
}
}
// For vector shift operation op, fold
// (op x, (and y, ((1 << numbits(x)) - 1))) -> (target op x, y)
static SDValue stripModuloOnShift(const TargetLowering &TLI, SDNode *N,
SelectionDAG &DAG) {
SDValue N0 = N->getOperand(0);
SDValue N1 = N->getOperand(1);
EVT VT = N0.getValueType();
unsigned OpSizeInBits = VT.getScalarSizeInBits();
unsigned Opcode = N->getOpcode();
unsigned TargetOpcode;
switch (Opcode) {
default:
llvm_unreachable("Unexpected shift operation");
case ISD::SHL:
TargetOpcode = PPCISD::SHL;
break;
case ISD::SRL:
TargetOpcode = PPCISD::SRL;
break;
case ISD::SRA:
TargetOpcode = PPCISD::SRA;
break;
}
if (VT.isVector() && TLI.isOperationLegal(Opcode, VT) &&
N1->getOpcode() == ISD::AND)
if (ConstantSDNode *Mask = isConstOrConstSplat(N1->getOperand(1)))
if (Mask->getZExtValue() == OpSizeInBits - 1)
return DAG.getNode(TargetOpcode, SDLoc(N), VT, N0, N1->getOperand(0));
return SDValue();
}
SDValue PPCTargetLowering::combineSHL(SDNode *N, DAGCombinerInfo &DCI) const {
if (auto Value = stripModuloOnShift(*this, N, DCI.DAG))
return Value;
SDValue N0 = N->getOperand(0);
ConstantSDNode *CN1 = dyn_cast<ConstantSDNode>(N->getOperand(1));
if (!Subtarget.isISA3_0() || !Subtarget.isPPC64() ||
N0.getOpcode() != ISD::SIGN_EXTEND ||
N0.getOperand(0).getValueType() != MVT::i32 || CN1 == nullptr ||
N->getValueType(0) != MVT::i64)
return SDValue();
// We can't save an operation here if the value is already extended, and
// the existing shift is easier to combine.
SDValue ExtsSrc = N0.getOperand(0);
if (ExtsSrc.getOpcode() == ISD::TRUNCATE &&
ExtsSrc.getOperand(0).getOpcode() == ISD::AssertSext)
return SDValue();
SDLoc DL(N0);
SDValue ShiftBy = SDValue(CN1, 0);
// We want the shift amount to be i32 on the extswli, but the shift could
// have an i64.
if (ShiftBy.getValueType() == MVT::i64)
ShiftBy = DCI.DAG.getConstant(CN1->getZExtValue(), DL, MVT::i32);
return DCI.DAG.getNode(PPCISD::EXTSWSLI, DL, MVT::i64, N0->getOperand(0),
ShiftBy);
}
SDValue PPCTargetLowering::combineSRA(SDNode *N, DAGCombinerInfo &DCI) const {
if (auto Value = stripModuloOnShift(*this, N, DCI.DAG))
return Value;
return SDValue();
}
SDValue PPCTargetLowering::combineSRL(SDNode *N, DAGCombinerInfo &DCI) const {
if (auto Value = stripModuloOnShift(*this, N, DCI.DAG))
return Value;
return SDValue();
}
// Transform (add X, (zext(setne Z, C))) -> (addze X, (addic (addi Z, -C), -1))
// Transform (add X, (zext(sete Z, C))) -> (addze X, (subfic (addi Z, -C), 0))
// When C is zero, the equation (addi Z, -C) can be simplified to Z
// Requirement: -C in [-32768, 32767], X and Z are MVT::i64 types
static SDValue combineADDToADDZE(SDNode *N, SelectionDAG &DAG,
const PPCSubtarget &Subtarget) {
if (!Subtarget.isPPC64())
return SDValue();
SDValue LHS = N->getOperand(0);
SDValue RHS = N->getOperand(1);
auto isZextOfCompareWithConstant = [](SDValue Op) {
if (Op.getOpcode() != ISD::ZERO_EXTEND || !Op.hasOneUse() ||
Op.getValueType() != MVT::i64)
return false;
SDValue Cmp = Op.getOperand(0);
if (Cmp.getOpcode() != ISD::SETCC || !Cmp.hasOneUse() ||
Cmp.getOperand(0).getValueType() != MVT::i64)
return false;
if (auto *Constant = dyn_cast<ConstantSDNode>(Cmp.getOperand(1))) {
int64_t NegConstant = 0 - Constant->getSExtValue();
// Due to the limitations of the addi instruction,
// -C is required to be [-32768, 32767].
return isInt<16>(NegConstant);
}
return false;
};
bool LHSHasPattern = isZextOfCompareWithConstant(LHS);
bool RHSHasPattern = isZextOfCompareWithConstant(RHS);
// If there is a pattern, canonicalize a zext operand to the RHS.
if (LHSHasPattern && !RHSHasPattern)
std::swap(LHS, RHS);
else if (!LHSHasPattern && !RHSHasPattern)
return SDValue();
SDLoc DL(N);
SDVTList VTs = DAG.getVTList(MVT::i64, MVT::Glue);
SDValue Cmp = RHS.getOperand(0);
SDValue Z = Cmp.getOperand(0);
auto *Constant = cast<ConstantSDNode>(Cmp.getOperand(1));
int64_t NegConstant = 0 - Constant->getSExtValue();
switch(cast<CondCodeSDNode>(Cmp.getOperand(2))->get()) {
default: break;
case ISD::SETNE: {
// when C == 0
// --> addze X, (addic Z, -1).carry
// /
// add X, (zext(setne Z, C))--
// \ when -32768 <= -C <= 32767 && C != 0
// --> addze X, (addic (addi Z, -C), -1).carry
SDValue Add = DAG.getNode(ISD::ADD, DL, MVT::i64, Z,
DAG.getConstant(NegConstant, DL, MVT::i64));
SDValue AddOrZ = NegConstant != 0 ? Add : Z;
SDValue Addc = DAG.getNode(ISD::ADDC, DL, DAG.getVTList(MVT::i64, MVT::Glue),
AddOrZ, DAG.getConstant(-1ULL, DL, MVT::i64));
return DAG.getNode(ISD::ADDE, DL, VTs, LHS, DAG.getConstant(0, DL, MVT::i64),
SDValue(Addc.getNode(), 1));
}
case ISD::SETEQ: {
// when C == 0
// --> addze X, (subfic Z, 0).carry
// /
// add X, (zext(sete Z, C))--
// \ when -32768 <= -C <= 32767 && C != 0
// --> addze X, (subfic (addi Z, -C), 0).carry
SDValue Add = DAG.getNode(ISD::ADD, DL, MVT::i64, Z,
DAG.getConstant(NegConstant, DL, MVT::i64));
SDValue AddOrZ = NegConstant != 0 ? Add : Z;
SDValue Subc = DAG.getNode(ISD::SUBC, DL, DAG.getVTList(MVT::i64, MVT::Glue),
DAG.getConstant(0, DL, MVT::i64), AddOrZ);
return DAG.getNode(ISD::ADDE, DL, VTs, LHS, DAG.getConstant(0, DL, MVT::i64),
SDValue(Subc.getNode(), 1));
}
}
return SDValue();
}
// Transform
// (add C1, (MAT_PCREL_ADDR GlobalAddr+C2)) to
// (MAT_PCREL_ADDR GlobalAddr+(C1+C2))
// In this case both C1 and C2 must be known constants.
// C1+C2 must fit into a 34 bit signed integer.
static SDValue combineADDToMAT_PCREL_ADDR(SDNode *N, SelectionDAG &DAG,
const PPCSubtarget &Subtarget) {
if (!Subtarget.isUsingPCRelativeCalls())
return SDValue();
// Check both Operand 0 and Operand 1 of the ADD node for the PCRel node.
// If we find that node try to cast the Global Address and the Constant.
SDValue LHS = N->getOperand(0);
SDValue RHS = N->getOperand(1);
if (LHS.getOpcode() != PPCISD::MAT_PCREL_ADDR)
std::swap(LHS, RHS);
if (LHS.getOpcode() != PPCISD::MAT_PCREL_ADDR)
return SDValue();
// Operand zero of PPCISD::MAT_PCREL_ADDR is the GA node.
GlobalAddressSDNode *GSDN = dyn_cast<GlobalAddressSDNode>(LHS.getOperand(0));
ConstantSDNode* ConstNode = dyn_cast<ConstantSDNode>(RHS);
// Check that both casts succeeded.
if (!GSDN || !ConstNode)
return SDValue();
int64_t NewOffset = GSDN->getOffset() + ConstNode->getSExtValue();
SDLoc DL(GSDN);
// The signed int offset needs to fit in 34 bits.
if (!isInt<34>(NewOffset))
return SDValue();
// The new global address is a copy of the old global address except
// that it has the updated Offset.
SDValue GA =
DAG.getTargetGlobalAddress(GSDN->getGlobal(), DL, GSDN->getValueType(0),
NewOffset, GSDN->getTargetFlags());
SDValue MatPCRel =
DAG.getNode(PPCISD::MAT_PCREL_ADDR, DL, GSDN->getValueType(0), GA);
return MatPCRel;
}
SDValue PPCTargetLowering::combineADD(SDNode *N, DAGCombinerInfo &DCI) const {
if (auto Value = combineADDToADDZE(N, DCI.DAG, Subtarget))
return Value;
if (auto Value = combineADDToMAT_PCREL_ADDR(N, DCI.DAG, Subtarget))
return Value;
return SDValue();
}
// Detect TRUNCATE operations on bitcasts of float128 values.
// What we are looking for here is the situtation where we extract a subset
// of bits from a 128 bit float.
// This can be of two forms:
// 1) BITCAST of f128 feeding TRUNCATE
// 2) BITCAST of f128 feeding SRL (a shift) feeding TRUNCATE
// The reason this is required is because we do not have a legal i128 type
// and so we want to prevent having to store the f128 and then reload part
// of it.
SDValue PPCTargetLowering::combineTRUNCATE(SDNode *N,
DAGCombinerInfo &DCI) const {
// If we are using CRBits then try that first.
if (Subtarget.useCRBits()) {
// Check if CRBits did anything and return that if it did.
if (SDValue CRTruncValue = DAGCombineTruncBoolExt(N, DCI))
return CRTruncValue;
}
SDLoc dl(N);
SDValue Op0 = N->getOperand(0);
// fold (truncate (abs (sub (zext a), (zext b)))) -> (vabsd a, b)
if (Subtarget.hasP9Altivec() && Op0.getOpcode() == ISD::ABS) {
EVT VT = N->getValueType(0);
if (VT != MVT::v4i32 && VT != MVT::v8i16 && VT != MVT::v16i8)
return SDValue();
SDValue Sub = Op0.getOperand(0);
if (Sub.getOpcode() == ISD::SUB) {
SDValue SubOp0 = Sub.getOperand(0);
SDValue SubOp1 = Sub.getOperand(1);
if ((SubOp0.getOpcode() == ISD::ZERO_EXTEND) &&
(SubOp1.getOpcode() == ISD::ZERO_EXTEND)) {
return DCI.DAG.getNode(PPCISD::VABSD, dl, VT, SubOp0.getOperand(0),
SubOp1.getOperand(0),
DCI.DAG.getTargetConstant(0, dl, MVT::i32));
}
}
}
// Looking for a truncate of i128 to i64.
if (Op0.getValueType() != MVT::i128 || N->getValueType(0) != MVT::i64)
return SDValue();
int EltToExtract = DCI.DAG.getDataLayout().isBigEndian() ? 1 : 0;
// SRL feeding TRUNCATE.
if (Op0.getOpcode() == ISD::SRL) {
ConstantSDNode *ConstNode = dyn_cast<ConstantSDNode>(Op0.getOperand(1));
// The right shift has to be by 64 bits.
if (!ConstNode || ConstNode->getZExtValue() != 64)
return SDValue();
// Switch the element number to extract.
EltToExtract = EltToExtract ? 0 : 1;
// Update Op0 past the SRL.
Op0 = Op0.getOperand(0);
}
// BITCAST feeding a TRUNCATE possibly via SRL.
if (Op0.getOpcode() == ISD::BITCAST &&
Op0.getValueType() == MVT::i128 &&
Op0.getOperand(0).getValueType() == MVT::f128) {
SDValue Bitcast = DCI.DAG.getBitcast(MVT::v2i64, Op0.getOperand(0));
return DCI.DAG.getNode(
ISD::EXTRACT_VECTOR_ELT, dl, MVT::i64, Bitcast,
DCI.DAG.getTargetConstant(EltToExtract, dl, MVT::i32));
}
return SDValue();
}
SDValue PPCTargetLowering::combineMUL(SDNode *N, DAGCombinerInfo &DCI) const {
SelectionDAG &DAG = DCI.DAG;
ConstantSDNode *ConstOpOrElement = isConstOrConstSplat(N->getOperand(1));
if (!ConstOpOrElement)
return SDValue();
// An imul is usually smaller than the alternative sequence for legal type.
if (DAG.getMachineFunction().getFunction().hasMinSize() &&
isOperationLegal(ISD::MUL, N->getValueType(0)))
return SDValue();
auto IsProfitable = [this](bool IsNeg, bool IsAddOne, EVT VT) -> bool {
switch (this->Subtarget.getCPUDirective()) {
default:
// TODO: enhance the condition for subtarget before pwr8
return false;
case PPC::DIR_PWR8:
// type mul add shl
// scalar 4 1 1
// vector 7 2 2
return true;
case PPC::DIR_PWR9:
case PPC::DIR_PWR10:
case PPC::DIR_PWR_FUTURE:
// type mul add shl
// scalar 5 2 2
// vector 7 2 2
// The cycle RATIO of related operations are showed as a table above.
// Because mul is 5(scalar)/7(vector), add/sub/shl are all 2 for both
// scalar and vector type. For 2 instrs patterns, add/sub + shl
// are 4, it is always profitable; but for 3 instrs patterns
// (mul x, -(2^N + 1)) => -(add (shl x, N), x), sub + add + shl are 6.
// So we should only do it for vector type.
return IsAddOne && IsNeg ? VT.isVector() : true;
}
};
EVT VT = N->getValueType(0);
SDLoc DL(N);
const APInt &MulAmt = ConstOpOrElement->getAPIntValue();
bool IsNeg = MulAmt.isNegative();
APInt MulAmtAbs = MulAmt.abs();
if ((MulAmtAbs - 1).isPowerOf2()) {
// (mul x, 2^N + 1) => (add (shl x, N), x)
// (mul x, -(2^N + 1)) => -(add (shl x, N), x)
if (!IsProfitable(IsNeg, true, VT))
return SDValue();
SDValue Op0 = N->getOperand(0);
SDValue Op1 =
DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
DAG.getConstant((MulAmtAbs - 1).logBase2(), DL, VT));
SDValue Res = DAG.getNode(ISD::ADD, DL, VT, Op0, Op1);
if (!IsNeg)
return Res;
return DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), Res);
} else if ((MulAmtAbs + 1).isPowerOf2()) {
// (mul x, 2^N - 1) => (sub (shl x, N), x)
// (mul x, -(2^N - 1)) => (sub x, (shl x, N))
if (!IsProfitable(IsNeg, false, VT))
return SDValue();
SDValue Op0 = N->getOperand(0);
SDValue Op1 =
DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
DAG.getConstant((MulAmtAbs + 1).logBase2(), DL, VT));
if (!IsNeg)
return DAG.getNode(ISD::SUB, DL, VT, Op1, Op0);
else
return DAG.getNode(ISD::SUB, DL, VT, Op0, Op1);
} else {
return SDValue();
}
}
// Combine fma-like op (like fnmsub) with fnegs to appropriate op. Do this
// in combiner since we need to check SD flags and other subtarget features.
SDValue PPCTargetLowering::combineFMALike(SDNode *N,
DAGCombinerInfo &DCI) const {
SDValue N0 = N->getOperand(0);
SDValue N1 = N->getOperand(1);
SDValue N2 = N->getOperand(2);
SDNodeFlags Flags = N->getFlags();
EVT VT = N->getValueType(0);
SelectionDAG &DAG = DCI.DAG;
const TargetOptions &Options = getTargetMachine().Options;
unsigned Opc = N->getOpcode();
bool CodeSize = DAG.getMachineFunction().getFunction().hasOptSize();
bool LegalOps = !DCI.isBeforeLegalizeOps();
SDLoc Loc(N);
if (!isOperationLegal(ISD::FMA, VT))
return SDValue();
// Allowing transformation to FNMSUB may change sign of zeroes when ab-c=0
// since (fnmsub a b c)=-0 while c-ab=+0.
if (!Flags.hasNoSignedZeros() && !Options.NoSignedZerosFPMath)
return SDValue();
// (fma (fneg a) b c) => (fnmsub a b c)
// (fnmsub (fneg a) b c) => (fma a b c)
if (SDValue NegN0 = getCheaperNegatedExpression(N0, DAG, LegalOps, CodeSize))
return DAG.getNode(invertFMAOpcode(Opc), Loc, VT, NegN0, N1, N2, Flags);
// (fma a (fneg b) c) => (fnmsub a b c)
// (fnmsub a (fneg b) c) => (fma a b c)
if (SDValue NegN1 = getCheaperNegatedExpression(N1, DAG, LegalOps, CodeSize))
return DAG.getNode(invertFMAOpcode(Opc), Loc, VT, N0, NegN1, N2, Flags);
return SDValue();
}
bool PPCTargetLowering::mayBeEmittedAsTailCall(const CallInst *CI) const {
// Only duplicate to increase tail-calls for the 64bit SysV ABIs.
if (!Subtarget.is64BitELFABI())
return false;
// If not a tail call then no need to proceed.
if (!CI->isTailCall())
return false;
// If sibling calls have been disabled and tail-calls aren't guaranteed
// there is no reason to duplicate.
auto &TM = getTargetMachine();
if (!TM.Options.GuaranteedTailCallOpt && DisableSCO)
return false;
// Can't tail call a function called indirectly, or if it has variadic args.
const Function *Callee = CI->getCalledFunction();
if (!Callee || Callee->isVarArg())
return false;
// Make sure the callee and caller calling conventions are eligible for tco.
const Function *Caller = CI->getParent()->getParent();
if (!areCallingConvEligibleForTCO_64SVR4(Caller->getCallingConv(),
CI->getCallingConv()))
return false;
// If the function is local then we have a good chance at tail-calling it
return getTargetMachine().shouldAssumeDSOLocal(*Caller->getParent(), Callee);
}
bool PPCTargetLowering::hasBitPreservingFPLogic(EVT VT) const {
if (!Subtarget.hasVSX())
return false;
if (Subtarget.hasP9Vector() && VT == MVT::f128)
return true;
return VT == MVT::f32 || VT == MVT::f64 ||
VT == MVT::v4f32 || VT == MVT::v2f64;
}
bool PPCTargetLowering::
isMaskAndCmp0FoldingBeneficial(const Instruction &AndI) const {
const Value *Mask = AndI.getOperand(1);
// If the mask is suitable for andi. or andis. we should sink the and.
if (const ConstantInt *CI = dyn_cast<ConstantInt>(Mask)) {
// Can't handle constants wider than 64-bits.
if (CI->getBitWidth() > 64)
return false;
int64_t ConstVal = CI->getZExtValue();
return isUInt<16>(ConstVal) ||
(isUInt<16>(ConstVal >> 16) && !(ConstVal & 0xFFFF));
}
// For non-constant masks, we can always use the record-form and.
return true;
}
// Transform (abs (sub (zext a), (zext b))) to (vabsd a b 0)
// Transform (abs (sub (zext a), (zext_invec b))) to (vabsd a b 0)
// Transform (abs (sub (zext_invec a), (zext_invec b))) to (vabsd a b 0)
// Transform (abs (sub (zext_invec a), (zext b))) to (vabsd a b 0)
// Transform (abs (sub a, b) to (vabsd a b 1)) if a & b of type v4i32
SDValue PPCTargetLowering::combineABS(SDNode *N, DAGCombinerInfo &DCI) const {
assert((N->getOpcode() == ISD::ABS) && "Need ABS node here");
assert(Subtarget.hasP9Altivec() &&
"Only combine this when P9 altivec supported!");
EVT VT = N->getValueType(0);
if (VT != MVT::v4i32 && VT != MVT::v8i16 && VT != MVT::v16i8)
return SDValue();
SelectionDAG &DAG = DCI.DAG;
SDLoc dl(N);
if (N->getOperand(0).getOpcode() == ISD::SUB) {
// Even for signed integers, if it's known to be positive (as signed
// integer) due to zero-extended inputs.
unsigned SubOpcd0 = N->getOperand(0)->getOperand(0).getOpcode();
unsigned SubOpcd1 = N->getOperand(0)->getOperand(1).getOpcode();
if ((SubOpcd0 == ISD::ZERO_EXTEND ||
SubOpcd0 == ISD::ZERO_EXTEND_VECTOR_INREG) &&
(SubOpcd1 == ISD::ZERO_EXTEND ||
SubOpcd1 == ISD::ZERO_EXTEND_VECTOR_INREG)) {
return DAG.getNode(PPCISD::VABSD, dl, N->getOperand(0).getValueType(),
N->getOperand(0)->getOperand(0),
N->getOperand(0)->getOperand(1),
DAG.getTargetConstant(0, dl, MVT::i32));
}
// For type v4i32, it can be optimized with xvnegsp + vabsduw
if (N->getOperand(0).getValueType() == MVT::v4i32 &&
N->getOperand(0).hasOneUse()) {
return DAG.getNode(PPCISD::VABSD, dl, N->getOperand(0).getValueType(),
N->getOperand(0)->getOperand(0),
N->getOperand(0)->getOperand(1),
DAG.getTargetConstant(1, dl, MVT::i32));
}
}
return SDValue();
}
// For type v4i32/v8ii16/v16i8, transform
// from (vselect (setcc a, b, setugt), (sub a, b), (sub b, a)) to (vabsd a, b)
// from (vselect (setcc a, b, setuge), (sub a, b), (sub b, a)) to (vabsd a, b)
// from (vselect (setcc a, b, setult), (sub b, a), (sub a, b)) to (vabsd a, b)
// from (vselect (setcc a, b, setule), (sub b, a), (sub a, b)) to (vabsd a, b)
SDValue PPCTargetLowering::combineVSelect(SDNode *N,
DAGCombinerInfo &DCI) const {
assert((N->getOpcode() == ISD::VSELECT) && "Need VSELECT node here");
assert(Subtarget.hasP9Altivec() &&
"Only combine this when P9 altivec supported!");
SelectionDAG &DAG = DCI.DAG;
SDLoc dl(N);
SDValue Cond = N->getOperand(0);
SDValue TrueOpnd = N->getOperand(1);
SDValue FalseOpnd = N->getOperand(2);
EVT VT = N->getOperand(1).getValueType();
if (Cond.getOpcode() != ISD::SETCC || TrueOpnd.getOpcode() != ISD::SUB ||
FalseOpnd.getOpcode() != ISD::SUB)
return SDValue();
// ABSD only available for type v4i32/v8i16/v16i8
if (VT != MVT::v4i32 && VT != MVT::v8i16 && VT != MVT::v16i8)
return SDValue();
// At least to save one more dependent computation
if (!(Cond.hasOneUse() || TrueOpnd.hasOneUse() || FalseOpnd.hasOneUse()))
return SDValue();
ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
// Can only handle unsigned comparison here
switch (CC) {
default:
return SDValue();
case ISD::SETUGT:
case ISD::SETUGE:
break;
case ISD::SETULT:
case ISD::SETULE:
std::swap(TrueOpnd, FalseOpnd);
break;
}
SDValue CmpOpnd1 = Cond.getOperand(0);
SDValue CmpOpnd2 = Cond.getOperand(1);
// SETCC CmpOpnd1 CmpOpnd2 cond
// TrueOpnd = CmpOpnd1 - CmpOpnd2
// FalseOpnd = CmpOpnd2 - CmpOpnd1
if (TrueOpnd.getOperand(0) == CmpOpnd1 &&
TrueOpnd.getOperand(1) == CmpOpnd2 &&
FalseOpnd.getOperand(0) == CmpOpnd2 &&
FalseOpnd.getOperand(1) == CmpOpnd1) {
return DAG.getNode(PPCISD::VABSD, dl, N->getOperand(1).getValueType(),
CmpOpnd1, CmpOpnd2,
DAG.getTargetConstant(0, dl, MVT::i32));
}
return SDValue();
}
/// getAddrModeForFlags - Based on the set of address flags, select the most
/// optimal instruction format to match by.
PPC::AddrMode PPCTargetLowering::getAddrModeForFlags(unsigned Flags) const {
// This is not a node we should be handling here.
if (Flags == PPC::MOF_None)
return PPC::AM_None;
// Unaligned D-Forms are tried first, followed by the aligned D-Forms.
for (auto FlagSet : AddrModesMap.at(PPC::AM_DForm))
if ((Flags & FlagSet) == FlagSet)
return PPC::AM_DForm;
for (auto FlagSet : AddrModesMap.at(PPC::AM_DSForm))
if ((Flags & FlagSet) == FlagSet)
return PPC::AM_DSForm;
for (auto FlagSet : AddrModesMap.at(PPC::AM_DQForm))
if ((Flags & FlagSet) == FlagSet)
return PPC::AM_DQForm;
for (auto FlagSet : AddrModesMap.at(PPC::AM_PrefixDForm))
if ((Flags & FlagSet) == FlagSet)
return PPC::AM_PrefixDForm;
// If no other forms are selected, return an X-Form as it is the most
// general addressing mode.
return PPC::AM_XForm;
}
/// Set alignment flags based on whether or not the Frame Index is aligned.
/// Utilized when computing flags for address computation when selecting
/// load and store instructions.
static void setAlignFlagsForFI(SDValue N, unsigned &FlagSet,
SelectionDAG &DAG) {
bool IsAdd = ((N.getOpcode() == ISD::ADD) || (N.getOpcode() == ISD::OR));
FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(IsAdd ? N.getOperand(0) : N);
if (!FI)
return;
const MachineFrameInfo &MFI = DAG.getMachineFunction().getFrameInfo();
unsigned FrameIndexAlign = MFI.getObjectAlign(FI->getIndex()).value();
// If this is (add $FI, $S16Imm), the alignment flags are already set
// based on the immediate. We just need to clear the alignment flags
// if the FI alignment is weaker.
if ((FrameIndexAlign % 4) != 0)
FlagSet &= ~PPC::MOF_RPlusSImm16Mult4;
if ((FrameIndexAlign % 16) != 0)
FlagSet &= ~PPC::MOF_RPlusSImm16Mult16;
// If the address is a plain FrameIndex, set alignment flags based on
// FI alignment.
if (!IsAdd) {
if ((FrameIndexAlign % 4) == 0)
FlagSet |= PPC::MOF_RPlusSImm16Mult4;
if ((FrameIndexAlign % 16) == 0)
FlagSet |= PPC::MOF_RPlusSImm16Mult16;
}
}
/// Given a node, compute flags that are used for address computation when
/// selecting load and store instructions. The flags computed are stored in
/// FlagSet. This function takes into account whether the node is a constant,
/// an ADD, OR, or a constant, and computes the address flags accordingly.
static void computeFlagsForAddressComputation(SDValue N, unsigned &FlagSet,
SelectionDAG &DAG) {
// Set the alignment flags for the node depending on if the node is
// 4-byte or 16-byte aligned.
auto SetAlignFlagsForImm = [&](uint64_t Imm) {
if ((Imm & 0x3) == 0)
FlagSet |= PPC::MOF_RPlusSImm16Mult4;
if ((Imm & 0xf) == 0)
FlagSet |= PPC::MOF_RPlusSImm16Mult16;
};
if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) {
// All 32-bit constants can be computed as LIS + Disp.
const APInt &ConstImm = CN->getAPIntValue();
if (ConstImm.isSignedIntN(32)) { // Flag to handle 32-bit constants.
FlagSet |= PPC::MOF_AddrIsSImm32;
SetAlignFlagsForImm(ConstImm.getZExtValue());
setAlignFlagsForFI(N, FlagSet, DAG);
}
if (ConstImm.isSignedIntN(34)) // Flag to handle 34-bit constants.
FlagSet |= PPC::MOF_RPlusSImm34;
else // Let constant materialization handle large constants.
FlagSet |= PPC::MOF_NotAddNorCst;
} else if (N.getOpcode() == ISD::ADD || provablyDisjointOr(DAG, N)) {
// This address can be represented as an addition of:
// - Register + Imm16 (possibly a multiple of 4/16)
// - Register + Imm34
// - Register + PPCISD::Lo
// - Register + Register
// In any case, we won't have to match this as Base + Zero.
SDValue RHS = N.getOperand(1);
if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(RHS)) {
const APInt &ConstImm = CN->getAPIntValue();
if (ConstImm.isSignedIntN(16)) {
FlagSet |= PPC::MOF_RPlusSImm16; // Signed 16-bit immediates.
SetAlignFlagsForImm(ConstImm.getZExtValue());
setAlignFlagsForFI(N, FlagSet, DAG);
}
if (ConstImm.isSignedIntN(34))
FlagSet |= PPC::MOF_RPlusSImm34; // Signed 34-bit immediates.
else
FlagSet |= PPC::MOF_RPlusR; // Register.
} else if (RHS.getOpcode() == PPCISD::Lo &&
!cast<ConstantSDNode>(RHS.getOperand(1))->getZExtValue())
FlagSet |= PPC::MOF_RPlusLo; // PPCISD::Lo.
else
FlagSet |= PPC::MOF_RPlusR;
} else { // The address computation is not a constant or an addition.
setAlignFlagsForFI(N, FlagSet, DAG);
FlagSet |= PPC::MOF_NotAddNorCst;
}
}
static bool isPCRelNode(SDValue N) {
return (N.getOpcode() == PPCISD::MAT_PCREL_ADDR ||
isValidPCRelNode<ConstantPoolSDNode>(N) ||
isValidPCRelNode<GlobalAddressSDNode>(N) ||
isValidPCRelNode<JumpTableSDNode>(N) ||
isValidPCRelNode<BlockAddressSDNode>(N));
}
/// computeMOFlags - Given a node N and it's Parent (a MemSDNode), compute
/// the address flags of the load/store instruction that is to be matched.
unsigned PPCTargetLowering::computeMOFlags(const SDNode *Parent, SDValue N,
SelectionDAG &DAG) const {
unsigned FlagSet = PPC::MOF_None;
// Compute subtarget flags.
if (!Subtarget.hasP9Vector())
FlagSet |= PPC::MOF_SubtargetBeforeP9;
else {
FlagSet |= PPC::MOF_SubtargetP9;
if (Subtarget.hasPrefixInstrs())
FlagSet |= PPC::MOF_SubtargetP10;
}
if (Subtarget.hasSPE())
FlagSet |= PPC::MOF_SubtargetSPE;
// Check if we have a PCRel node and return early.
if ((FlagSet & PPC::MOF_SubtargetP10) && isPCRelNode(N))
return FlagSet;
// If the node is the paired load/store intrinsics, compute flags for
// address computation and return early.
unsigned ParentOp = Parent->getOpcode();
if (Subtarget.isISA3_1() && ((ParentOp == ISD::INTRINSIC_W_CHAIN) ||
(ParentOp == ISD::INTRINSIC_VOID))) {
unsigned ID = cast<ConstantSDNode>(Parent->getOperand(1))->getZExtValue();
if ((ID == Intrinsic::ppc_vsx_lxvp) || (ID == Intrinsic::ppc_vsx_stxvp)) {
SDValue IntrinOp = (ID == Intrinsic::ppc_vsx_lxvp)
? Parent->getOperand(2)
: Parent->getOperand(3);
computeFlagsForAddressComputation(IntrinOp, FlagSet, DAG);
FlagSet |= PPC::MOF_Vector;
return FlagSet;
}
}
// Mark this as something we don't want to handle here if it is atomic
// or pre-increment instruction.
if (const LSBaseSDNode *LSB = dyn_cast<LSBaseSDNode>(Parent))
if (LSB->isIndexed())
return PPC::MOF_None;
// Compute in-memory type flags. This is based on if there are scalars,
// floats or vectors.
const MemSDNode *MN = dyn_cast<MemSDNode>(Parent);
assert(MN && "Parent should be a MemSDNode!");
EVT MemVT = MN->getMemoryVT();
unsigned Size = MemVT.getSizeInBits();
if (MemVT.isScalarInteger()) {
assert(Size <= 128 &&
"Not expecting scalar integers larger than 16 bytes!");
if (Size < 32)
FlagSet |= PPC::MOF_SubWordInt;
else if (Size == 32)
FlagSet |= PPC::MOF_WordInt;
else
FlagSet |= PPC::MOF_DoubleWordInt;
} else if (MemVT.isVector() && !MemVT.isFloatingPoint()) { // Integer vectors.
if (Size == 128)
FlagSet |= PPC::MOF_Vector;
else if (Size == 256) {
assert(Subtarget.pairedVectorMemops() &&
"256-bit vectors are only available when paired vector memops is "
"enabled!");
FlagSet |= PPC::MOF_Vector;
} else
llvm_unreachable("Not expecting illegal vectors!");
} else { // Floating point type: can be scalar, f128 or vector types.
if (Size == 32 || Size == 64)
FlagSet |= PPC::MOF_ScalarFloat;
else if (MemVT == MVT::f128 || MemVT.isVector())
FlagSet |= PPC::MOF_Vector;
else
llvm_unreachable("Not expecting illegal scalar floats!");
}
// Compute flags for address computation.
computeFlagsForAddressComputation(N, FlagSet, DAG);
// Compute type extension flags.
if (const LoadSDNode *LN = dyn_cast<LoadSDNode>(Parent)) {
switch (LN->getExtensionType()) {
case ISD::SEXTLOAD:
FlagSet |= PPC::MOF_SExt;
break;
case ISD::EXTLOAD:
case ISD::ZEXTLOAD:
FlagSet |= PPC::MOF_ZExt;
break;
case ISD::NON_EXTLOAD:
FlagSet |= PPC::MOF_NoExt;
break;
}
} else
FlagSet |= PPC::MOF_NoExt;
// For integers, no extension is the same as zero extension.
// We set the extension mode to zero extension so we don't have
// to add separate entries in AddrModesMap for loads and stores.
if (MemVT.isScalarInteger() && (FlagSet & PPC::MOF_NoExt)) {
FlagSet |= PPC::MOF_ZExt;
FlagSet &= ~PPC::MOF_NoExt;
}
// If we don't have prefixed instructions, 34-bit constants should be
// treated as PPC::MOF_NotAddNorCst so they can match D-Forms.
bool IsNonP1034BitConst =
((PPC::MOF_RPlusSImm34 | PPC::MOF_AddrIsSImm32 | PPC::MOF_SubtargetP10) &
FlagSet) == PPC::MOF_RPlusSImm34;
if (N.getOpcode() != ISD::ADD && N.getOpcode() != ISD::OR &&
IsNonP1034BitConst)
FlagSet |= PPC::MOF_NotAddNorCst;
return FlagSet;
}
/// SelectForceXFormMode - Given the specified address, force it to be
/// represented as an indexed [r+r] operation (an XForm instruction).
PPC::AddrMode PPCTargetLowering::SelectForceXFormMode(SDValue N, SDValue &Disp,
SDValue &Base,
SelectionDAG &DAG) const {
PPC::AddrMode Mode = PPC::AM_XForm;
int16_t ForceXFormImm = 0;
if (provablyDisjointOr(DAG, N) &&
!isIntS16Immediate(N.getOperand(1), ForceXFormImm)) {
Disp = N.getOperand(0);
Base = N.getOperand(1);
return Mode;
}
// If the address is the result of an add, we will utilize the fact that the
// address calculation includes an implicit add. However, we can reduce
// register pressure if we do not materialize a constant just for use as the
// index register. We only get rid of the add if it is not an add of a
// value and a 16-bit signed constant and both have a single use.
if (N.getOpcode() == ISD::ADD &&
(!isIntS16Immediate(N.getOperand(1), ForceXFormImm) ||
!N.getOperand(1).hasOneUse() || !N.getOperand(0).hasOneUse())) {
Disp = N.getOperand(0);
Base = N.getOperand(1);
return Mode;
}
// Otherwise, use R0 as the base register.
Disp = DAG.getRegister(Subtarget.isPPC64() ? PPC::ZERO8 : PPC::ZERO,
N.getValueType());
Base = N;
return Mode;
}
bool PPCTargetLowering::splitValueIntoRegisterParts(
SelectionDAG &DAG, const SDLoc &DL, SDValue Val, SDValue *Parts,
unsigned NumParts, MVT PartVT, Optional<CallingConv::ID> CC) const {
EVT ValVT = Val.getValueType();
// If we are splitting a scalar integer into f64 parts (i.e. so they
// can be placed into VFRC registers), we need to zero extend and
// bitcast the values. This will ensure the value is placed into a
// VSR using direct moves or stack operations as needed.
if (PartVT == MVT::f64 &&
(ValVT == MVT::i32 || ValVT == MVT::i16 || ValVT == MVT::i8)) {
Val = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i64, Val);
Val = DAG.getNode(ISD::BITCAST, DL, MVT::f64, Val);
Parts[0] = Val;
return true;
}
return false;
}
// If we happen to match to an aligned D-Form, check if the Frame Index is
// adequately aligned. If it is not, reset the mode to match to X-Form.
static void setXFormForUnalignedFI(SDValue N, unsigned Flags,
PPC::AddrMode &Mode) {
if (!isa<FrameIndexSDNode>(N))
return;
if ((Mode == PPC::AM_DSForm && !(Flags & PPC::MOF_RPlusSImm16Mult4)) ||
(Mode == PPC::AM_DQForm && !(Flags & PPC::MOF_RPlusSImm16Mult16)))
Mode = PPC::AM_XForm;
}
/// SelectOptimalAddrMode - Based on a node N and it's Parent (a MemSDNode),
/// compute the address flags of the node, get the optimal address mode based
/// on the flags, and set the Base and Disp based on the address mode.
PPC::AddrMode PPCTargetLowering::SelectOptimalAddrMode(const SDNode *Parent,
SDValue N, SDValue &Disp,
SDValue &Base,
SelectionDAG &DAG,
MaybeAlign Align) const {
SDLoc DL(Parent);
// Compute the address flags.
unsigned Flags = computeMOFlags(Parent, N, DAG);
// Get the optimal address mode based on the Flags.
PPC::AddrMode Mode = getAddrModeForFlags(Flags);
// If the address mode is DS-Form or DQ-Form, check if the FI is aligned.
// Select an X-Form load if it is not.
setXFormForUnalignedFI(N, Flags, Mode);
// Set the mode to PC-Relative addressing mode if we have a valid PC-Rel node.
if ((Mode == PPC::AM_XForm) && isPCRelNode(N)) {
assert(Subtarget.isUsingPCRelativeCalls() &&
"Must be using PC-Relative calls when a valid PC-Relative node is "
"present!");
Mode = PPC::AM_PCRel;
}
// Set Base and Disp accordingly depending on the address mode.
switch (Mode) {
case PPC::AM_DForm:
case PPC::AM_DSForm:
case PPC::AM_DQForm: {
// This is a register plus a 16-bit immediate. The base will be the
// register and the displacement will be the immediate unless it
// isn't sufficiently aligned.
if (Flags & PPC::MOF_RPlusSImm16) {
SDValue Op0 = N.getOperand(0);
SDValue Op1 = N.getOperand(1);
int16_t Imm = cast<ConstantSDNode>(Op1)->getAPIntValue().getZExtValue();
if (!Align || isAligned(*Align, Imm)) {
Disp = DAG.getTargetConstant(Imm, DL, N.getValueType());
Base = Op0;
if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Op0)) {
Base = DAG.getTargetFrameIndex(FI->getIndex(), N.getValueType());
fixupFuncForFI(DAG, FI->getIndex(), N.getValueType());
}
break;
}
}
// This is a register plus the @lo relocation. The base is the register
// and the displacement is the global address.
else if (Flags & PPC::MOF_RPlusLo) {
Disp = N.getOperand(1).getOperand(0); // The global address.
assert(Disp.getOpcode() == ISD::TargetGlobalAddress ||
Disp.getOpcode() == ISD::TargetGlobalTLSAddress ||
Disp.getOpcode() == ISD::TargetConstantPool ||
Disp.getOpcode() == ISD::TargetJumpTable);
Base = N.getOperand(0);
break;
}
// This is a constant address at most 32 bits. The base will be
// zero or load-immediate-shifted and the displacement will be
// the low 16 bits of the address.
else if (Flags & PPC::MOF_AddrIsSImm32) {
auto *CN = cast<ConstantSDNode>(N);
EVT CNType = CN->getValueType(0);
uint64_t CNImm = CN->getZExtValue();
// If this address fits entirely in a 16-bit sext immediate field, codegen
// this as "d, 0".
int16_t Imm;
if (isIntS16Immediate(CN, Imm) && (!Align || isAligned(*Align, Imm))) {
Disp = DAG.getTargetConstant(Imm, DL, CNType);
Base = DAG.getRegister(Subtarget.isPPC64() ? PPC::ZERO8 : PPC::ZERO,
CNType);
break;
}
// Handle 32-bit sext immediate with LIS + Addr mode.
if ((CNType == MVT::i32 || isInt<32>(CNImm)) &&
(!Align || isAligned(*Align, CNImm))) {
int32_t Addr = (int32_t)CNImm;
// Otherwise, break this down into LIS + Disp.
Disp = DAG.getTargetConstant((int16_t)Addr, DL, MVT::i32);
Base =
DAG.getTargetConstant((Addr - (int16_t)Addr) >> 16, DL, MVT::i32);
uint32_t LIS = CNType == MVT::i32 ? PPC::LIS : PPC::LIS8;
Base = SDValue(DAG.getMachineNode(LIS, DL, CNType, Base), 0);
break;
}
}
// Otherwise, the PPC:MOF_NotAdd flag is set. Load/Store is Non-foldable.
Disp = DAG.getTargetConstant(0, DL, getPointerTy(DAG.getDataLayout()));
if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N)) {
Base = DAG.getTargetFrameIndex(FI->getIndex(), N.getValueType());
fixupFuncForFI(DAG, FI->getIndex(), N.getValueType());
} else
Base = N;
break;
}
case PPC::AM_PrefixDForm: {
int64_t Imm34 = 0;
unsigned Opcode = N.getOpcode();
if (((Opcode == ISD::ADD) || (Opcode == ISD::OR)) &&
(isIntS34Immediate(N.getOperand(1), Imm34))) {
// N is an Add/OR Node, and it's operand is a 34-bit signed immediate.
Disp = DAG.getTargetConstant(Imm34, DL, N.getValueType());
if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N.getOperand(0)))
Base = DAG.getTargetFrameIndex(FI->getIndex(), N.getValueType());
else
Base = N.getOperand(0);
} else if (isIntS34Immediate(N, Imm34)) {
// The address is a 34-bit signed immediate.
Disp = DAG.getTargetConstant(Imm34, DL, N.getValueType());
Base = DAG.getRegister(PPC::ZERO8, N.getValueType());
}
break;
}
case PPC::AM_PCRel: {
// When selecting PC-Relative instructions, "Base" is not utilized as
// we select the address as [PC+imm].
Disp = N;
break;
}
case PPC::AM_None:
break;
default: { // By default, X-Form is always available to be selected.
// When a frame index is not aligned, we also match by XForm.
FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(N);
Base = FI ? N : N.getOperand(1);
Disp = FI ? DAG.getRegister(Subtarget.isPPC64() ? PPC::ZERO8 : PPC::ZERO,
N.getValueType())
: N.getOperand(0);
break;
}
}
return Mode;
}
CCAssignFn *PPCTargetLowering::ccAssignFnForCall(CallingConv::ID CC,
bool Return,
bool IsVarArg) const {
switch (CC) {
case CallingConv::Cold:
return (Return ? RetCC_PPC_Cold : CC_PPC64_ELF_FIS);
default:
return CC_PPC64_ELF_FIS;
}
}
TargetLowering::AtomicExpansionKind
PPCTargetLowering::shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const {
unsigned Size = AI->getType()->getPrimitiveSizeInBits();
if (EnableQuadwordAtomics && Subtarget.hasQuadwordAtomics() && Size == 128)
return AtomicExpansionKind::MaskedIntrinsic;
return TargetLowering::shouldExpandAtomicRMWInIR(AI);
}
TargetLowering::AtomicExpansionKind
PPCTargetLowering::shouldExpandAtomicCmpXchgInIR(AtomicCmpXchgInst *AI) const {
unsigned Size = AI->getNewValOperand()->getType()->getPrimitiveSizeInBits();
if (EnableQuadwordAtomics && Subtarget.hasQuadwordAtomics() && Size == 128)
return AtomicExpansionKind::MaskedIntrinsic;
return TargetLowering::shouldExpandAtomicCmpXchgInIR(AI);
}
static Intrinsic::ID
getIntrinsicForAtomicRMWBinOp128(AtomicRMWInst::BinOp BinOp) {
switch (BinOp) {
default:
llvm_unreachable("Unexpected AtomicRMW BinOp");
case AtomicRMWInst::Xchg:
return Intrinsic::ppc_atomicrmw_xchg_i128;
case AtomicRMWInst::Add:
return Intrinsic::ppc_atomicrmw_add_i128;
case AtomicRMWInst::Sub:
return Intrinsic::ppc_atomicrmw_sub_i128;
case AtomicRMWInst::And:
return Intrinsic::ppc_atomicrmw_and_i128;
case AtomicRMWInst::Or:
return Intrinsic::ppc_atomicrmw_or_i128;
case AtomicRMWInst::Xor:
return Intrinsic::ppc_atomicrmw_xor_i128;
case AtomicRMWInst::Nand:
return Intrinsic::ppc_atomicrmw_nand_i128;
}
}
Value *PPCTargetLowering::emitMaskedAtomicRMWIntrinsic(
IRBuilderBase &Builder, AtomicRMWInst *AI, Value *AlignedAddr, Value *Incr,
Value *Mask, Value *ShiftAmt, AtomicOrdering Ord) const {
assert(EnableQuadwordAtomics && Subtarget.hasQuadwordAtomics() &&
"Only support quadword now");
Module *M = Builder.GetInsertBlock()->getParent()->getParent();
Type *ValTy = AlignedAddr->getType()->getPointerElementType();
assert(ValTy->getPrimitiveSizeInBits() == 128);
Function *RMW = Intrinsic::getDeclaration(
M, getIntrinsicForAtomicRMWBinOp128(AI->getOperation()));
Type *Int64Ty = Type::getInt64Ty(M->getContext());
Value *IncrLo = Builder.CreateTrunc(Incr, Int64Ty, "incr_lo");
Value *IncrHi =
Builder.CreateTrunc(Builder.CreateLShr(Incr, 64), Int64Ty, "incr_hi");
Value *Addr =
Builder.CreateBitCast(AlignedAddr, Type::getInt8PtrTy(M->getContext()));
Value *LoHi = Builder.CreateCall(RMW, {Addr, IncrLo, IncrHi});
Value *Lo = Builder.CreateExtractValue(LoHi, 0, "lo");
Value *Hi = Builder.CreateExtractValue(LoHi, 1, "hi");
Lo = Builder.CreateZExt(Lo, ValTy, "lo64");
Hi = Builder.CreateZExt(Hi, ValTy, "hi64");
return Builder.CreateOr(
Lo, Builder.CreateShl(Hi, ConstantInt::get(ValTy, 64)), "val64");
}
Value *PPCTargetLowering::emitMaskedAtomicCmpXchgIntrinsic(
IRBuilderBase &Builder, AtomicCmpXchgInst *CI, Value *AlignedAddr,
Value *CmpVal, Value *NewVal, Value *Mask, AtomicOrdering Ord) const {
assert(EnableQuadwordAtomics && Subtarget.hasQuadwordAtomics() &&
"Only support quadword now");
Module *M = Builder.GetInsertBlock()->getParent()->getParent();
Type *ValTy = AlignedAddr->getType()->getPointerElementType();
assert(ValTy->getPrimitiveSizeInBits() == 128);
Function *IntCmpXchg =
Intrinsic::getDeclaration(M, Intrinsic::ppc_cmpxchg_i128);
Type *Int64Ty = Type::getInt64Ty(M->getContext());
Value *CmpLo = Builder.CreateTrunc(CmpVal, Int64Ty, "cmp_lo");
Value *CmpHi =
Builder.CreateTrunc(Builder.CreateLShr(CmpVal, 64), Int64Ty, "cmp_hi");
Value *NewLo = Builder.CreateTrunc(NewVal, Int64Ty, "new_lo");
Value *NewHi =
Builder.CreateTrunc(Builder.CreateLShr(NewVal, 64), Int64Ty, "new_hi");
Value *Addr =
Builder.CreateBitCast(AlignedAddr, Type::getInt8PtrTy(M->getContext()));
emitLeadingFence(Builder, CI, Ord);
Value *LoHi =
Builder.CreateCall(IntCmpXchg, {Addr, CmpLo, CmpHi, NewLo, NewHi});
emitTrailingFence(Builder, CI, Ord);
Value *Lo = Builder.CreateExtractValue(LoHi, 0, "lo");
Value *Hi = Builder.CreateExtractValue(LoHi, 1, "hi");
Lo = Builder.CreateZExt(Lo, ValTy, "lo64");
Hi = Builder.CreateZExt(Hi, ValTy, "hi64");
return Builder.CreateOr(
Lo, Builder.CreateShl(Hi, ConstantInt::get(ValTy, 64)), "val64");
}
diff --git a/lib/clang/include/VCSVersion.inc b/lib/clang/include/VCSVersion.inc
index f6331a01fb05..90a7417a7de5 100644
--- a/lib/clang/include/VCSVersion.inc
+++ b/lib/clang/include/VCSVersion.inc
@@ -1,14 +1,10 @@
// $FreeBSD$
-#define LLVM_REVISION "llvmorg-14-init-18294-gdb01b123d012"
+#define LLVM_REVISION "llvmorg-14-init-18315-g190be5457c90"
#define LLVM_REPOSITORY "https://github.com/llvm/llvm-project.git"
-#define CLANG_REVISION "llvmorg-14-init-18294-gdb01b123d012"
+#define CLANG_REVISION "llvmorg-14-init-18315-g190be5457c90"
#define CLANG_REPOSITORY "https://github.com/llvm/llvm-project.git"
-// <Upstream revision at import>-<Local identifier in __FreeBSD_version style>
-#define LLD_REVISION "llvmorg-14-init-18294-gdb01b123d012-1400003"
-#define LLD_REPOSITORY "FreeBSD"
-
-#define LLDB_REVISION "llvmorg-14-init-18294-gdb01b123d012"
+#define LLDB_REVISION "llvmorg-14-init-18315-g190be5457c90"
#define LLDB_REPOSITORY "https://github.com/llvm/llvm-project.git"
diff --git a/lib/clang/include/lld/Common/Version.inc b/lib/clang/include/lld/Common/Version.inc
index 4aef2b1a92c3..b4ef011bf5cd 100644
--- a/lib/clang/include/lld/Common/Version.inc
+++ b/lib/clang/include/lld/Common/Version.inc
@@ -1,3 +1,4 @@
-// $FreeBSD$
+// Local identifier in __FreeBSD_version style
+#define LLD_FREEBSD_VERSION 1400003
-#define LLD_VERSION_STRING "14.0.0"
+#define LLD_VERSION_STRING "14.0.0 (FreeBSD llvmorg-14-init-18315-g190be5457c90-" __XSTRING(LLD_FREEBSD_VERSION) ")"
diff --git a/lib/clang/include/llvm/Support/VCSRevision.h b/lib/clang/include/llvm/Support/VCSRevision.h
index 82234f64fcc6..cb157cf33f8e 100644
--- a/lib/clang/include/llvm/Support/VCSRevision.h
+++ b/lib/clang/include/llvm/Support/VCSRevision.h
@@ -1,3 +1,3 @@
/* $FreeBSD$ */
-#define LLVM_REVISION "llvmorg-14-init-18294-gdb01b123d012"
+#define LLVM_REVISION "llvmorg-14-init-18315-g190be5457c90"
#define LLVM_REPOSITORY "https://github.com/llvm/llvm-project.git"
diff --git a/lib/clang/libclang/Makefile b/lib/clang/libclang/Makefile
index 5cd8fee60b7f..a2612bc9d894 100644
--- a/lib/clang/libclang/Makefile
+++ b/lib/clang/libclang/Makefile
@@ -1,1102 +1,1105 @@
# $FreeBSD$
.include <src.opts.mk>
.include "../clang.pre.mk"
LIB= clang
CFLAGS+= -I${.OBJDIR}
CFLAGS+= -I${OBJTOP}/lib/clang/libllvm
CFLAGS+= -I${CLANG_SRCS}/lib/Basic
CFLAGS+= -I${CLANG_SRCS}/lib/Driver
# Ensure FREEBSD_CC_VERSION is defined for Basic/Targets.cpp
CFLAGS.Targets.cpp+= -include ../freebsd_cc_version.h
# Work around GCC bug 67888
.if ${COMPILER_TYPE} == "gcc"
CXXFLAGS.Module.cpp+= -fpermissive
.endif
SRCDIR= clang/lib
# Explanation of different SRCS variants below:
# SRCS_MIN: always required, even for bootstrap
# SRCS_EXT: required for MK_CLANG_EXTRAS || MK_CLANG_FORMAT
# SRCS_FUL: required for MK_CLANG_FULL
# SRCS_LDB: required for MK_LLDB
SRCS_FUL+= ARCMigrate/ARCMT.cpp
SRCS_FUL+= ARCMigrate/ARCMTActions.cpp
SRCS_FUL+= ARCMigrate/FileRemapper.cpp
SRCS_FUL+= ARCMigrate/ObjCMT.cpp
SRCS_FUL+= ARCMigrate/PlistReporter.cpp
SRCS_FUL+= ARCMigrate/TransAPIUses.cpp
SRCS_FUL+= ARCMigrate/TransARCAssign.cpp
SRCS_FUL+= ARCMigrate/TransAutoreleasePool.cpp
SRCS_FUL+= ARCMigrate/TransBlockObjCVariable.cpp
SRCS_FUL+= ARCMigrate/TransEmptyStatementsAndDealloc.cpp
SRCS_FUL+= ARCMigrate/TransGCAttrs.cpp
SRCS_FUL+= ARCMigrate/TransGCCalls.cpp
SRCS_FUL+= ARCMigrate/TransProperties.cpp
SRCS_FUL+= ARCMigrate/TransProtectedScope.cpp
SRCS_FUL+= ARCMigrate/TransRetainReleaseDealloc.cpp
SRCS_FUL+= ARCMigrate/TransUnbridgedCasts.cpp
SRCS_FUL+= ARCMigrate/TransUnusedInitDelegate.cpp
SRCS_FUL+= ARCMigrate/TransZeroOutPropsInDealloc.cpp
SRCS_FUL+= ARCMigrate/TransformActions.cpp
SRCS_FUL+= ARCMigrate/Transforms.cpp
SRCS_MIN+= AST/APValue.cpp
SRCS_MIN+= AST/ASTConcept.cpp
SRCS_MIN+= AST/ASTConsumer.cpp
SRCS_MIN+= AST/ASTContext.cpp
SRCS_MIN+= AST/ASTDiagnostic.cpp
SRCS_MIN+= AST/ASTDumper.cpp
SRCS_MIN+= AST/ASTImporter.cpp
SRCS_MIN+= AST/ASTImporterLookupTable.cpp
SRCS_MIN+= AST/ASTStructuralEquivalence.cpp
SRCS_MIN+= AST/ASTTypeTraits.cpp
SRCS_MIN+= AST/AttrImpl.cpp
SRCS_MIN+= AST/CXXInheritance.cpp
SRCS_MIN+= AST/Comment.cpp
SRCS_MIN+= AST/CommentBriefParser.cpp
SRCS_MIN+= AST/CommentCommandTraits.cpp
SRCS_MIN+= AST/CommentLexer.cpp
SRCS_MIN+= AST/CommentParser.cpp
SRCS_MIN+= AST/CommentSema.cpp
SRCS_MIN+= AST/ComparisonCategories.cpp
SRCS_MIN+= AST/ComputeDependence.cpp
SRCS_FUL+= AST/DataCollection.cpp
SRCS_MIN+= AST/Decl.cpp
SRCS_MIN+= AST/DeclBase.cpp
SRCS_MIN+= AST/DeclCXX.cpp
SRCS_MIN+= AST/DeclFriend.cpp
SRCS_MIN+= AST/DeclGroup.cpp
SRCS_MIN+= AST/DeclObjC.cpp
SRCS_MIN+= AST/DeclOpenMP.cpp
SRCS_MIN+= AST/DeclPrinter.cpp
SRCS_MIN+= AST/DeclTemplate.cpp
SRCS_MIN+= AST/DeclarationName.cpp
SRCS_MIN+= AST/Expr.cpp
SRCS_MIN+= AST/ExprCXX.cpp
SRCS_MIN+= AST/ExprClassification.cpp
SRCS_MIN+= AST/ExprConcepts.cpp
SRCS_MIN+= AST/ExprConstant.cpp
SRCS_MIN+= AST/ExprObjC.cpp
SRCS_LDB+= AST/ExternalASTMerger.cpp
SRCS_MIN+= AST/ExternalASTSource.cpp
SRCS_MIN+= AST/FormatString.cpp
SRCS_MIN+= AST/InheritViz.cpp
SRCS_MIN+= AST/Interp/ByteCodeEmitter.cpp
SRCS_MIN+= AST/Interp/ByteCodeExprGen.cpp
SRCS_MIN+= AST/Interp/ByteCodeGenError.cpp
SRCS_MIN+= AST/Interp/ByteCodeStmtGen.cpp
SRCS_MIN+= AST/Interp/Context.cpp
SRCS_MIN+= AST/Interp/Descriptor.cpp
SRCS_MIN+= AST/Interp/EvalEmitter.cpp
SRCS_MIN+= AST/Interp/Frame.cpp
SRCS_MIN+= AST/Interp/Function.cpp
SRCS_MIN+= AST/Interp/Interp.cpp
SRCS_MIN+= AST/Interp/InterpBlock.cpp
SRCS_MIN+= AST/Interp/InterpFrame.cpp
SRCS_MIN+= AST/Interp/InterpStack.cpp
SRCS_MIN+= AST/Interp/InterpState.cpp
SRCS_MIN+= AST/Interp/Pointer.cpp
SRCS_MIN+= AST/Interp/PrimType.cpp
SRCS_MIN+= AST/Interp/Program.cpp
SRCS_MIN+= AST/Interp/Record.cpp
SRCS_MIN+= AST/Interp/Source.cpp
SRCS_MIN+= AST/Interp/State.cpp
SRCS_MIN+= AST/ItaniumCXXABI.cpp
SRCS_MIN+= AST/ItaniumMangle.cpp
SRCS_MIN+= AST/JSONNodeDumper.cpp
SRCS_MIN+= AST/Mangle.cpp
SRCS_MIN+= AST/MicrosoftCXXABI.cpp
SRCS_MIN+= AST/MicrosoftMangle.cpp
SRCS_MIN+= AST/NSAPI.cpp
SRCS_MIN+= AST/NestedNameSpecifier.cpp
SRCS_MIN+= AST/ODRHash.cpp
SRCS_MIN+= AST/OSLog.cpp
SRCS_MIN+= AST/OpenMPClause.cpp
SRCS_MIN+= AST/ParentMap.cpp
SRCS_MIN+= AST/ParentMapContext.cpp
SRCS_MIN+= AST/PrintfFormatString.cpp
SRCS_MIN+= AST/QualTypeNames.cpp
SRCS_MIN+= AST/RawCommentList.cpp
SRCS_MIN+= AST/RecordLayout.cpp
SRCS_MIN+= AST/RecordLayoutBuilder.cpp
SRCS_MIN+= AST/ScanfFormatString.cpp
SRCS_MIN+= AST/SelectorLocationsKind.cpp
SRCS_MIN+= AST/Stmt.cpp
SRCS_MIN+= AST/StmtCXX.cpp
SRCS_MIN+= AST/StmtIterator.cpp
SRCS_MIN+= AST/StmtObjC.cpp
SRCS_MIN+= AST/StmtOpenMP.cpp
SRCS_MIN+= AST/StmtPrinter.cpp
SRCS_MIN+= AST/StmtProfile.cpp
SRCS_MIN+= AST/StmtViz.cpp
SRCS_MIN+= AST/TemplateBase.cpp
SRCS_MIN+= AST/TemplateName.cpp
SRCS_MIN+= AST/TextNodeDumper.cpp
SRCS_MIN+= AST/Type.cpp
SRCS_MIN+= AST/TypeLoc.cpp
SRCS_MIN+= AST/TypePrinter.cpp
SRCS_MIN+= AST/VTTBuilder.cpp
SRCS_MIN+= AST/VTableBuilder.cpp
SRCS_MIN+= ASTMatchers/ASTMatchFinder.cpp
SRCS_MIN+= ASTMatchers/ASTMatchersInternal.cpp
SRCS_MIN+= ASTMatchers/Dynamic/Diagnostics.cpp
SRCS_MIN+= ASTMatchers/Dynamic/Registry.cpp
SRCS_MIN+= Analysis/AnalysisDeclContext.cpp
SRCS_MIN+= Analysis/BodyFarm.cpp
SRCS_MIN+= Analysis/CFG.cpp
SRCS_MIN+= Analysis/CFGReachabilityAnalysis.cpp
SRCS_MIN+= Analysis/CFGStmtMap.cpp
SRCS_FUL+= Analysis/CallGraph.cpp
SRCS_MIN+= Analysis/CalledOnceCheck.cpp
SRCS_MIN+= Analysis/CloneDetection.cpp
SRCS_MIN+= Analysis/CocoaConventions.cpp
SRCS_FUL+= Analysis/CodeInjector.cpp
SRCS_MIN+= Analysis/Consumed.cpp
SRCS_MIN+= Analysis/ConstructionContext.cpp
SRCS_FUL+= Analysis/Dominators.cpp
SRCS_MIN+= Analysis/ExprMutationAnalyzer.cpp
SRCS_FUL+= Analysis/IssueHash.cpp
SRCS_MIN+= Analysis/LiveVariables.cpp
SRCS_FUL+= Analysis/MacroExpansionContext.cpp
SRCS_MIN+= Analysis/ObjCNoReturn.cpp
SRCS_FUL+= Analysis/PathDiagnostic.cpp
SRCS_MIN+= Analysis/PostOrderCFGView.cpp
SRCS_FUL+= Analysis/ProgramPoint.cpp
SRCS_MIN+= Analysis/ReachableCode.cpp
SRCS_FUL+= Analysis/RetainSummaryManager.cpp
SRCS_MIN+= Analysis/ThreadSafety.cpp
SRCS_MIN+= Analysis/ThreadSafetyCommon.cpp
SRCS_MIN+= Analysis/ThreadSafetyTIL.cpp
SRCS_MIN+= Analysis/UninitializedValues.cpp
SRCS_MIN+= Basic/Attributes.cpp
SRCS_MIN+= Basic/Builtins.cpp
SRCS_MIN+= Basic/CLWarnings.cpp
SRCS_MIN+= Basic/CharInfo.cpp
SRCS_MIN+= Basic/CodeGenOptions.cpp
SRCS_MIN+= Basic/Cuda.cpp
SRCS_MIN+= Basic/DarwinSDKInfo.cpp
SRCS_MIN+= Basic/Diagnostic.cpp
SRCS_MIN+= Basic/DiagnosticIDs.cpp
SRCS_MIN+= Basic/DiagnosticOptions.cpp
SRCS_MIN+= Basic/ExpressionTraits.cpp
SRCS_MIN+= Basic/FileEntry.cpp
SRCS_MIN+= Basic/FileManager.cpp
SRCS_MIN+= Basic/FileSystemStatCache.cpp
SRCS_MIN+= Basic/IdentifierTable.cpp
SRCS_MIN+= Basic/LangOptions.cpp
SRCS_MIN+= Basic/LangStandards.cpp
SRCS_MIN+= Basic/Module.cpp
SRCS_MIN+= Basic/NoSanitizeList.cpp
SRCS_MIN+= Basic/ObjCRuntime.cpp
SRCS_MIN+= Basic/OpenCLOptions.cpp
SRCS_MIN+= Basic/OpenMPKinds.cpp
SRCS_MIN+= Basic/OperatorPrecedence.cpp
SRCS_MIN+= Basic/ProfileList.cpp
SRCS_MIN+= Basic/SanitizerSpecialCaseList.cpp
SRCS_MIN+= Basic/Sanitizers.cpp
SRCS_MIN+= Basic/SourceLocation.cpp
SRCS_MIN+= Basic/SourceManager.cpp
SRCS_MIN+= Basic/Stack.cpp
SRCS_MIN+= Basic/TargetID.cpp
SRCS_MIN+= Basic/TargetInfo.cpp
SRCS_MIN+= Basic/Targets.cpp
SRCS_MIN+= Basic/Targets/AArch64.cpp
SRCS_MIN+= Basic/Targets/AMDGPU.cpp
SRCS_MIN+= Basic/Targets/ARC.cpp
SRCS_MIN+= Basic/Targets/ARM.cpp
SRCS_MIN+= Basic/Targets/AVR.cpp
SRCS_MIN+= Basic/Targets/BPF.cpp
SRCS_MIN+= Basic/Targets/Hexagon.cpp
SRCS_MIN+= Basic/Targets/Lanai.cpp
SRCS_MIN+= Basic/Targets/Le64.cpp
SRCS_MIN+= Basic/Targets/M68k.cpp
SRCS_MIN+= Basic/Targets/Mips.cpp
SRCS_MIN+= Basic/Targets/MSP430.cpp
SRCS_MIN+= Basic/Targets/NVPTX.cpp
SRCS_MIN+= Basic/Targets/OSTargets.cpp
SRCS_MIN+= Basic/Targets/PNaCl.cpp
SRCS_MIN+= Basic/Targets/PPC.cpp
SRCS_MIN+= Basic/Targets/RISCV.cpp
SRCS_MIN+= Basic/Targets/SPIR.cpp
SRCS_MIN+= Basic/Targets/Sparc.cpp
SRCS_MIN+= Basic/Targets/SystemZ.cpp
SRCS_MIN+= Basic/Targets/TCE.cpp
SRCS_MIN+= Basic/Targets/VE.cpp
SRCS_MIN+= Basic/Targets/WebAssembly.cpp
SRCS_MIN+= Basic/Targets/X86.cpp
SRCS_MIN+= Basic/Targets/XCore.cpp
SRCS_MIN+= Basic/TokenKinds.cpp
SRCS_MIN+= Basic/TypeTraits.cpp
SRCS_MIN+= Basic/Version.cpp
SRCS_MIN+= Basic/Warnings.cpp
SRCS_MIN+= Basic/XRayInstr.cpp
SRCS_MIN+= Basic/XRayLists.cpp
SRCS_MIN+= CodeGen/BackendUtil.cpp
SRCS_MIN+= CodeGen/CGAtomic.cpp
SRCS_MIN+= CodeGen/CGBlocks.cpp
SRCS_MIN+= CodeGen/CGBuiltin.cpp
SRCS_MIN+= CodeGen/CGCUDANV.cpp
SRCS_MIN+= CodeGen/CGCUDARuntime.cpp
SRCS_MIN+= CodeGen/CGCXX.cpp
SRCS_MIN+= CodeGen/CGCXXABI.cpp
SRCS_MIN+= CodeGen/CGCall.cpp
SRCS_MIN+= CodeGen/CGClass.cpp
SRCS_MIN+= CodeGen/CGCleanup.cpp
SRCS_MIN+= CodeGen/CGCoroutine.cpp
SRCS_MIN+= CodeGen/CGDebugInfo.cpp
SRCS_MIN+= CodeGen/CGDecl.cpp
SRCS_MIN+= CodeGen/CGDeclCXX.cpp
SRCS_MIN+= CodeGen/CGException.cpp
SRCS_MIN+= CodeGen/CGExpr.cpp
SRCS_MIN+= CodeGen/CGExprAgg.cpp
SRCS_MIN+= CodeGen/CGExprCXX.cpp
SRCS_MIN+= CodeGen/CGExprComplex.cpp
SRCS_MIN+= CodeGen/CGExprConstant.cpp
SRCS_MIN+= CodeGen/CGExprScalar.cpp
SRCS_MIN+= CodeGen/CGGPUBuiltin.cpp
SRCS_MIN+= CodeGen/CGLoopInfo.cpp
SRCS_MIN+= CodeGen/CGNonTrivialStruct.cpp
SRCS_MIN+= CodeGen/CGObjC.cpp
SRCS_MIN+= CodeGen/CGObjCGNU.cpp
SRCS_MIN+= CodeGen/CGObjCMac.cpp
SRCS_MIN+= CodeGen/CGObjCRuntime.cpp
SRCS_MIN+= CodeGen/CGOpenCLRuntime.cpp
SRCS_MIN+= CodeGen/CGOpenMPRuntime.cpp
SRCS_MIN+= CodeGen/CGOpenMPRuntimeGPU.cpp
SRCS_MIN+= CodeGen/CGRecordLayoutBuilder.cpp
SRCS_MIN+= CodeGen/CGStmt.cpp
SRCS_MIN+= CodeGen/CGStmtOpenMP.cpp
SRCS_MIN+= CodeGen/CGVTT.cpp
SRCS_MIN+= CodeGen/CGVTables.cpp
SRCS_MIN+= CodeGen/CodeGenAction.cpp
SRCS_MIN+= CodeGen/CodeGenFunction.cpp
SRCS_MIN+= CodeGen/CodeGenModule.cpp
SRCS_MIN+= CodeGen/CodeGenPGO.cpp
SRCS_MIN+= CodeGen/CodeGenTBAA.cpp
SRCS_MIN+= CodeGen/CodeGenTypes.cpp
SRCS_MIN+= CodeGen/ConstantInitBuilder.cpp
SRCS_MIN+= CodeGen/CoverageMappingGen.cpp
SRCS_MIN+= CodeGen/ItaniumCXXABI.cpp
SRCS_MIN+= CodeGen/MacroPPCallbacks.cpp
SRCS_MIN+= CodeGen/MicrosoftCXXABI.cpp
SRCS_MIN+= CodeGen/ModuleBuilder.cpp
SRCS_MIN+= CodeGen/ObjectFilePCHContainerOperations.cpp
SRCS_MIN+= CodeGen/PatternInit.cpp
SRCS_MIN+= CodeGen/SanitizerMetadata.cpp
SRCS_MIN+= CodeGen/SwiftCallingConv.cpp
SRCS_MIN+= CodeGen/TargetInfo.cpp
SRCS_MIN+= CodeGen/VarBypassDetector.cpp
SRCS_FUL+= CrossTU/CrossTranslationUnit.cpp
SRCS_MIN+= Driver/Action.cpp
SRCS_MIN+= Driver/Compilation.cpp
SRCS_MIN+= Driver/Distro.cpp
SRCS_MIN+= Driver/Driver.cpp
SRCS_MIN+= Driver/DriverOptions.cpp
SRCS_MIN+= Driver/Job.cpp
SRCS_MIN+= Driver/Multilib.cpp
SRCS_MIN+= Driver/OptionUtils.cpp
SRCS_MIN+= Driver/Phases.cpp
SRCS_MIN+= Driver/SanitizerArgs.cpp
SRCS_MIN+= Driver/Tool.cpp
SRCS_MIN+= Driver/ToolChain.cpp
SRCS_MIN+= Driver/ToolChains/AIX.cpp
SRCS_MIN+= Driver/ToolChains/AMDGPU.cpp
SRCS_MIN+= Driver/ToolChains/AMDGPUOpenMP.cpp
SRCS_MIN+= Driver/ToolChains/AVR.cpp
SRCS_MIN+= Driver/ToolChains/Ananas.cpp
SRCS_MIN+= Driver/ToolChains/Arch/AArch64.cpp
SRCS_MIN+= Driver/ToolChains/Arch/ARM.cpp
SRCS_MIN+= Driver/ToolChains/Arch/M68k.cpp
SRCS_MIN+= Driver/ToolChains/Arch/Mips.cpp
SRCS_MIN+= Driver/ToolChains/Arch/PPC.cpp
SRCS_MIN+= Driver/ToolChains/Arch/RISCV.cpp
SRCS_MIN+= Driver/ToolChains/Arch/Sparc.cpp
SRCS_MIN+= Driver/ToolChains/Arch/SystemZ.cpp
SRCS_MIN+= Driver/ToolChains/Arch/VE.cpp
SRCS_MIN+= Driver/ToolChains/Arch/X86.cpp
SRCS_MIN+= Driver/ToolChains/BareMetal.cpp
SRCS_MIN+= Driver/ToolChains/Clang.cpp
SRCS_MIN+= Driver/ToolChains/CloudABI.cpp
SRCS_MIN+= Driver/ToolChains/CommonArgs.cpp
SRCS_MIN+= Driver/ToolChains/Contiki.cpp
SRCS_MIN+= Driver/ToolChains/CrossWindows.cpp
SRCS_MIN+= Driver/ToolChains/Cuda.cpp
SRCS_MIN+= Driver/ToolChains/Darwin.cpp
SRCS_MIN+= Driver/ToolChains/DragonFly.cpp
SRCS_MIN+= Driver/ToolChains/Flang.cpp
SRCS_MIN+= Driver/ToolChains/FreeBSD.cpp
SRCS_MIN+= Driver/ToolChains/Fuchsia.cpp
SRCS_MIN+= Driver/ToolChains/Gnu.cpp
SRCS_MIN+= Driver/ToolChains/HIPAMD.cpp
SRCS_MIN+= Driver/ToolChains/HIPSPV.cpp
SRCS_MIN+= Driver/ToolChains/HIPUtility.cpp
SRCS_MIN+= Driver/ToolChains/Haiku.cpp
SRCS_MIN+= Driver/ToolChains/Hexagon.cpp
SRCS_MIN+= Driver/ToolChains/Hurd.cpp
SRCS_MIN+= Driver/ToolChains/InterfaceStubs.cpp
SRCS_MIN+= Driver/ToolChains/Linux.cpp
SRCS_MIN+= Driver/ToolChains/MSP430.cpp
SRCS_MIN+= Driver/ToolChains/MSVC.cpp
SRCS_MIN+= Driver/ToolChains/MinGW.cpp
SRCS_MIN+= Driver/ToolChains/Minix.cpp
SRCS_MIN+= Driver/ToolChains/MipsLinux.cpp
SRCS_MIN+= Driver/ToolChains/Myriad.cpp
SRCS_MIN+= Driver/ToolChains/NaCl.cpp
SRCS_MIN+= Driver/ToolChains/NetBSD.cpp
SRCS_MIN+= Driver/ToolChains/OpenBSD.cpp
SRCS_MIN+= Driver/ToolChains/PPCFreeBSD.cpp
SRCS_MIN+= Driver/ToolChains/PPCLinux.cpp
SRCS_MIN+= Driver/ToolChains/PS4CPU.cpp
SRCS_MIN+= Driver/ToolChains/RISCVToolchain.cpp
SRCS_MIN+= Driver/ToolChains/SPIRV.cpp
SRCS_MIN+= Driver/ToolChains/Solaris.cpp
SRCS_MIN+= Driver/ToolChains/TCE.cpp
SRCS_MIN+= Driver/ToolChains/VEToolchain.cpp
SRCS_MIN+= Driver/ToolChains/WebAssembly.cpp
SRCS_MIN+= Driver/ToolChains/XCore.cpp
SRCS_MIN+= Driver/ToolChains/ZOS.cpp
SRCS_MIN+= Driver/Types.cpp
SRCS_MIN+= Driver/XRayArgs.cpp
SRCS_MIN+= Edit/Commit.cpp
SRCS_MIN+= Edit/EditedSource.cpp
SRCS_MIN+= Edit/RewriteObjCFoundationAPI.cpp
SRCS_EXT+= Format/AffectedRangeManager.cpp
SRCS_EXT+= Format/BreakableToken.cpp
SRCS_EXT+= Format/ContinuationIndenter.cpp
SRCS_EXT+= Format/DefinitionBlockSeparator.cpp
SRCS_EXT+= Format/Format.cpp
SRCS_EXT+= Format/FormatToken.cpp
SRCS_EXT+= Format/FormatTokenLexer.cpp
SRCS_EXT+= Format/NamespaceEndCommentsFixer.cpp
SRCS_EXT+= Format/QualifierAlignmentFixer.cpp
SRCS_EXT+= Format/SortJavaScriptImports.cpp
SRCS_EXT+= Format/TokenAnalyzer.cpp
SRCS_EXT+= Format/TokenAnnotator.cpp
SRCS_EXT+= Format/UnwrappedLineFormatter.cpp
SRCS_EXT+= Format/UnwrappedLineParser.cpp
SRCS_EXT+= Format/UsingDeclarationsSorter.cpp
SRCS_EXT+= Format/WhitespaceManager.cpp
SRCS_MIN+= Frontend/ASTConsumers.cpp
SRCS_MIN+= Frontend/ASTMerge.cpp
SRCS_MIN+= Frontend/ASTUnit.cpp
SRCS_MIN+= Frontend/ChainedDiagnosticConsumer.cpp
SRCS_MIN+= Frontend/ChainedIncludesSource.cpp
SRCS_MIN+= Frontend/CompilerInstance.cpp
SRCS_MIN+= Frontend/CompilerInvocation.cpp
SRCS_MIN+= Frontend/CreateInvocationFromCommandLine.cpp
SRCS_MIN+= Frontend/DependencyFile.cpp
SRCS_MIN+= Frontend/DependencyGraph.cpp
SRCS_MIN+= Frontend/DiagnosticRenderer.cpp
SRCS_MIN+= Frontend/ExtractAPIConsumer.cpp
SRCS_MIN+= Frontend/FrontendAction.cpp
SRCS_MIN+= Frontend/FrontendActions.cpp
SRCS_MIN+= Frontend/FrontendOptions.cpp
SRCS_MIN+= Frontend/HeaderIncludeGen.cpp
SRCS_MIN+= Frontend/InitPreprocessor.cpp
SRCS_MIN+= Frontend/InterfaceStubFunctionsConsumer.cpp
SRCS_MIN+= Frontend/LayoutOverrideSource.cpp
SRCS_MIN+= Frontend/LogDiagnosticPrinter.cpp
SRCS_MIN+= Frontend/ModuleDependencyCollector.cpp
SRCS_MIN+= Frontend/MultiplexConsumer.cpp
SRCS_MIN+= Frontend/PrecompiledPreamble.cpp
SRCS_MIN+= Frontend/PrintPreprocessedOutput.cpp
SRCS_MIN+= Frontend/Rewrite/FixItRewriter.cpp
SRCS_MIN+= Frontend/Rewrite/FrontendActions.cpp
SRCS_MIN+= Frontend/Rewrite/HTMLPrint.cpp
SRCS_MIN+= Frontend/Rewrite/InclusionRewriter.cpp
SRCS_MIN+= Frontend/Rewrite/RewriteMacros.cpp
SRCS_MIN+= Frontend/Rewrite/RewriteTest.cpp
SRCS_MIN+= Frontend/SerializedDiagnosticPrinter.cpp
SRCS_MIN+= Frontend/SerializedDiagnosticReader.cpp
SRCS_MIN+= Frontend/TestModuleFileExtension.cpp
SRCS_MIN+= Frontend/TextDiagnostic.cpp
SRCS_MIN+= Frontend/TextDiagnosticBuffer.cpp
SRCS_MIN+= Frontend/TextDiagnosticPrinter.cpp
SRCS_MIN+= Frontend/VerifyDiagnosticConsumer.cpp
SRCS_MIN+= FrontendTool/ExecuteCompilerInvocation.cpp
SRCS_MIN+= Index/CommentToXML.cpp
SRCS_MIN+= Index/IndexBody.cpp
SRCS_MIN+= Index/IndexDecl.cpp
SRCS_MIN+= Index/IndexSymbol.cpp
SRCS_MIN+= Index/IndexTypeSourceInfo.cpp
SRCS_MIN+= Index/IndexingAction.cpp
SRCS_MIN+= Index/IndexingContext.cpp
SRCS_MIN+= Index/USRGeneration.cpp
SRCS_MIN+= Lex/DependencyDirectivesSourceMinimizer.cpp
SRCS_MIN+= Lex/InitHeaderSearch.cpp
SRCS_MIN+= Lex/HeaderMap.cpp
SRCS_MIN+= Lex/HeaderSearch.cpp
SRCS_MIN+= Lex/Lexer.cpp
SRCS_MIN+= Lex/LiteralSupport.cpp
SRCS_MIN+= Lex/MacroArgs.cpp
SRCS_MIN+= Lex/MacroInfo.cpp
SRCS_MIN+= Lex/ModuleMap.cpp
SRCS_MIN+= Lex/PPCaching.cpp
SRCS_MIN+= Lex/PPCallbacks.cpp
SRCS_MIN+= Lex/PPConditionalDirectiveRecord.cpp
SRCS_MIN+= Lex/PPDirectives.cpp
SRCS_MIN+= Lex/PPExpressions.cpp
SRCS_MIN+= Lex/PPLexerChange.cpp
SRCS_MIN+= Lex/PPMacroExpansion.cpp
SRCS_MIN+= Lex/Pragma.cpp
SRCS_MIN+= Lex/PreprocessingRecord.cpp
SRCS_MIN+= Lex/Preprocessor.cpp
SRCS_MIN+= Lex/PreprocessorLexer.cpp
SRCS_MIN+= Lex/ScratchBuffer.cpp
SRCS_MIN+= Lex/TokenConcatenation.cpp
SRCS_MIN+= Lex/TokenLexer.cpp
SRCS_MIN+= Parse/ParseAST.cpp
SRCS_MIN+= Parse/ParseCXXInlineMethods.cpp
SRCS_MIN+= Parse/ParseDecl.cpp
SRCS_MIN+= Parse/ParseDeclCXX.cpp
SRCS_MIN+= Parse/ParseExpr.cpp
SRCS_MIN+= Parse/ParseExprCXX.cpp
SRCS_MIN+= Parse/ParseInit.cpp
SRCS_MIN+= Parse/ParseObjc.cpp
SRCS_MIN+= Parse/ParseOpenMP.cpp
SRCS_MIN+= Parse/ParsePragma.cpp
SRCS_MIN+= Parse/ParseStmt.cpp
SRCS_MIN+= Parse/ParseStmtAsm.cpp
SRCS_MIN+= Parse/ParseTemplate.cpp
SRCS_MIN+= Parse/ParseTentative.cpp
SRCS_MIN+= Parse/Parser.cpp
SRCS_MIN+= Rewrite/DeltaTree.cpp
SRCS_MIN+= Rewrite/HTMLRewrite.cpp
SRCS_MIN+= Rewrite/RewriteRope.cpp
SRCS_MIN+= Rewrite/Rewriter.cpp
SRCS_MIN+= Rewrite/TokenRewriter.cpp
SRCS_MIN+= Sema/AnalysisBasedWarnings.cpp
SRCS_MIN+= Sema/CodeCompleteConsumer.cpp
SRCS_MIN+= Sema/DeclSpec.cpp
SRCS_MIN+= Sema/DelayedDiagnostic.cpp
SRCS_MIN+= Sema/IdentifierResolver.cpp
SRCS_MIN+= Sema/JumpDiagnostics.cpp
SRCS_MIN+= Sema/MultiplexExternalSemaSource.cpp
SRCS_MIN+= Sema/ParsedAttr.cpp
SRCS_MIN+= Sema/Scope.cpp
SRCS_MIN+= Sema/ScopeInfo.cpp
SRCS_MIN+= Sema/Sema.cpp
SRCS_MIN+= Sema/SemaAccess.cpp
SRCS_MIN+= Sema/SemaAttr.cpp
SRCS_MIN+= Sema/SemaAvailability.cpp
SRCS_MIN+= Sema/SemaCUDA.cpp
SRCS_MIN+= Sema/SemaCXXScopeSpec.cpp
SRCS_MIN+= Sema/SemaCast.cpp
SRCS_MIN+= Sema/SemaChecking.cpp
SRCS_MIN+= Sema/SemaCodeComplete.cpp
SRCS_MIN+= Sema/SemaConcept.cpp
SRCS_MIN+= Sema/SemaConsumer.cpp
SRCS_MIN+= Sema/SemaCoroutine.cpp
SRCS_MIN+= Sema/SemaDecl.cpp
SRCS_MIN+= Sema/SemaDeclAttr.cpp
SRCS_MIN+= Sema/SemaDeclCXX.cpp
SRCS_MIN+= Sema/SemaDeclObjC.cpp
SRCS_MIN+= Sema/SemaExceptionSpec.cpp
SRCS_MIN+= Sema/SemaExpr.cpp
SRCS_MIN+= Sema/SemaExprCXX.cpp
SRCS_MIN+= Sema/SemaExprMember.cpp
SRCS_MIN+= Sema/SemaExprObjC.cpp
SRCS_MIN+= Sema/SemaFixItUtils.cpp
SRCS_MIN+= Sema/SemaInit.cpp
SRCS_MIN+= Sema/SemaLambda.cpp
SRCS_MIN+= Sema/SemaLookup.cpp
SRCS_MIN+= Sema/SemaModule.cpp
SRCS_MIN+= Sema/SemaObjCProperty.cpp
SRCS_MIN+= Sema/SemaOpenMP.cpp
SRCS_MIN+= Sema/SemaOverload.cpp
SRCS_MIN+= Sema/SemaPseudoObject.cpp
SRCS_MIN+= Sema/SemaSYCL.cpp
SRCS_MIN+= Sema/SemaStmt.cpp
SRCS_MIN+= Sema/SemaStmtAsm.cpp
SRCS_MIN+= Sema/SemaStmtAttr.cpp
SRCS_MIN+= Sema/SemaTemplate.cpp
SRCS_MIN+= Sema/SemaTemplateDeduction.cpp
SRCS_MIN+= Sema/SemaTemplateInstantiate.cpp
SRCS_MIN+= Sema/SemaTemplateInstantiateDecl.cpp
SRCS_MIN+= Sema/SemaTemplateVariadic.cpp
SRCS_MIN+= Sema/SemaType.cpp
SRCS_MIN+= Sema/TypeLocBuilder.cpp
SRCS_MIN+= Serialization/ASTCommon.cpp
SRCS_MIN+= Serialization/ASTReader.cpp
SRCS_MIN+= Serialization/ASTReaderDecl.cpp
SRCS_MIN+= Serialization/ASTReaderStmt.cpp
SRCS_MIN+= Serialization/ASTWriter.cpp
SRCS_MIN+= Serialization/ASTWriterDecl.cpp
SRCS_MIN+= Serialization/ASTWriterStmt.cpp
SRCS_MIN+= Serialization/GeneratePCH.cpp
SRCS_MIN+= Serialization/GlobalModuleIndex.cpp
SRCS_MIN+= Serialization/InMemoryModuleCache.cpp
SRCS_MIN+= Serialization/ModuleFile.cpp
SRCS_MIN+= Serialization/ModuleFileExtension.cpp
SRCS_MIN+= Serialization/ModuleManager.cpp
SRCS_MIN+= Serialization/PCHContainerOperations.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/AnalysisOrderChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/AnalyzerStatsChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ArrayBoundChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/BlockInCriticalSectionChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/BoolAssignmentChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/BuiltinFunctionChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/GCDAntipatternChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/CStringChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/CStringSyntaxChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/CXXSelfAssignmentChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/CallAndMessageChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/CastSizeChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/CastToStructChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/CastValueChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/CheckObjCDealloc.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/CheckObjCInstMethSignature.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/CheckPlacementNew.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/CheckSizeofPointer.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ChrootChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/CloneChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ContainerModeling.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ConversionChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/DeadStoresChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/DebugCheckers.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/DebugContainerModeling.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/DebugIteratorModeling.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/DeleteWithNonVirtualDtorChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/DereferenceChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/DirectIvarAssignment.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/DivZeroChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/DynamicTypeChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/DynamicTypePropagation.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/EnumCastOutOfRangeChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ExprInspectionChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/FixedAddressChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/FuchsiaHandleChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/GTestChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/GenericTaintChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/IdenticalExprChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/InnerPointerChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/InvalidatedIteratorChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/Iterator.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/IteratorModeling.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/IteratorRangeChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/IvarInvalidationChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/LLVMConventionsChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/LocalizationChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/MIGChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/MPI-Checker/MPIFunctionClassifier.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/MacOSXAPIChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/MallocChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/MallocOverflowSecurityChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/MallocSizeofChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/MismatchedIteratorChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/MmapWriteExecChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/MoveChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/NSAutoreleasePoolChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/NSErrorChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/NoReturnFunctionChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/NonNullParamChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/NonnullGlobalConstantsChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/NullabilityChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/NumberObjectConversionChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/OSObjectCStyleCast.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ObjCAtSyncChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ObjCAutoreleaseWriteChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ObjCContainersASTChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ObjCContainersChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ObjCMissingSuperCallChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ObjCPropertyChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ObjCSuperDeallocChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/PaddingChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/PointerArithChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/PointerIterationChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/PointerSortingChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/PointerSubChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/PthreadLockChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ReturnUndefChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ReturnValueChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/RunLoopAutoreleaseLeakChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/STLAlgorithmModeling.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/SimpleStreamChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/SmartPtrChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/SmartPtrModeling.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/StackAddrEscapeChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/StreamChecker.cpp
+SRCS_FUL+= StaticAnalyzer/Checkers/StringChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/Taint.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/TaintTesterChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/TraversalChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/TrustNonnullChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/UndefBranchChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/UndefResultChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/UndefinedArraySubscriptChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/UninitializedObject/UninitializedObjectChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/UninitializedObject/UninitializedPointee.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/UnixAPIChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/UnreachableCodeChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/VLASizeChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/ValistChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/VforkChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/VirtualCallChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/cert/PutenvWithAutoChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/WebKit/ASTUtils.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/WebKit/NoUncountedMembersChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/WebKit/PtrTypesSemantics.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/WebKit/RefCntblBaseVirtualDtorChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/WebKit/UncountedCallArgsChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/WebKit/UncountedLambdaCapturesChecker.cpp
SRCS_FUL+= StaticAnalyzer/Checkers/WebKit/UncountedLocalVarsChecker.cpp
+SRCS_FUL+= StaticAnalyzer/Checkers/cert/InvalidPtrChecker.cpp
SRCS_FUL+= StaticAnalyzer/Core/APSIntType.cpp
SRCS_FUL+= StaticAnalyzer/Core/AnalysisManager.cpp
SRCS_FUL+= StaticAnalyzer/Core/AnalyzerOptions.cpp
SRCS_FUL+= StaticAnalyzer/Core/BasicValueFactory.cpp
SRCS_FUL+= StaticAnalyzer/Core/BlockCounter.cpp
SRCS_FUL+= StaticAnalyzer/Core/BugReporter.cpp
SRCS_FUL+= StaticAnalyzer/Core/BugReporterVisitors.cpp
+SRCS_FUL+= StaticAnalyzer/Core/CallDescription.cpp
SRCS_FUL+= StaticAnalyzer/Core/CallEvent.cpp
SRCS_FUL+= StaticAnalyzer/Core/Checker.cpp
SRCS_FUL+= StaticAnalyzer/Core/CheckerContext.cpp
SRCS_FUL+= StaticAnalyzer/Core/CheckerHelpers.cpp
SRCS_FUL+= StaticAnalyzer/Core/CheckerManager.cpp
SRCS_FUL+= StaticAnalyzer/Core/CheckerRegistryData.cpp
SRCS_FUL+= StaticAnalyzer/Core/CommonBugCategories.cpp
SRCS_FUL+= StaticAnalyzer/Core/ConstraintManager.cpp
SRCS_FUL+= StaticAnalyzer/Core/CoreEngine.cpp
SRCS_FUL+= StaticAnalyzer/Core/DynamicExtent.cpp
SRCS_FUL+= StaticAnalyzer/Core/DynamicType.cpp
SRCS_FUL+= StaticAnalyzer/Core/Environment.cpp
SRCS_FUL+= StaticAnalyzer/Core/ExplodedGraph.cpp
SRCS_FUL+= StaticAnalyzer/Core/ExprEngine.cpp
SRCS_FUL+= StaticAnalyzer/Core/ExprEngineC.cpp
SRCS_FUL+= StaticAnalyzer/Core/ExprEngineCXX.cpp
SRCS_FUL+= StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp
SRCS_FUL+= StaticAnalyzer/Core/ExprEngineObjC.cpp
SRCS_FUL+= StaticAnalyzer/Core/FunctionSummary.cpp
SRCS_FUL+= StaticAnalyzer/Core/HTMLDiagnostics.cpp
SRCS_FUL+= StaticAnalyzer/Core/LoopUnrolling.cpp
SRCS_FUL+= StaticAnalyzer/Core/LoopWidening.cpp
SRCS_FUL+= StaticAnalyzer/Core/MemRegion.cpp
SRCS_FUL+= StaticAnalyzer/Core/PlistDiagnostics.cpp
SRCS_FUL+= StaticAnalyzer/Core/ProgramState.cpp
SRCS_FUL+= StaticAnalyzer/Core/RangeConstraintManager.cpp
SRCS_FUL+= StaticAnalyzer/Core/RangedConstraintManager.cpp
SRCS_FUL+= StaticAnalyzer/Core/RegionStore.cpp
SRCS_FUL+= StaticAnalyzer/Core/SMTConstraintManager.cpp
SRCS_FUL+= StaticAnalyzer/Core/SValBuilder.cpp
SRCS_FUL+= StaticAnalyzer/Core/SVals.cpp
SRCS_FUL+= StaticAnalyzer/Core/SarifDiagnostics.cpp
SRCS_FUL+= StaticAnalyzer/Core/SimpleConstraintManager.cpp
SRCS_FUL+= StaticAnalyzer/Core/SimpleSValBuilder.cpp
SRCS_FUL+= StaticAnalyzer/Core/Store.cpp
SRCS_FUL+= StaticAnalyzer/Core/SymbolManager.cpp
SRCS_FUL+= StaticAnalyzer/Core/TextDiagnostics.cpp
SRCS_FUL+= StaticAnalyzer/Core/WorkList.cpp
SRCS_FUL+= StaticAnalyzer/Frontend/AnalysisConsumer.cpp
SRCS_FUL+= StaticAnalyzer/Frontend/AnalyzerHelpFlags.cpp
SRCS_FUL+= StaticAnalyzer/Frontend/CheckerRegistry.cpp
SRCS_FUL+= StaticAnalyzer/Frontend/CreateCheckerManager.cpp
SRCS_FUL+= StaticAnalyzer/Frontend/FrontendActions.cpp
SRCS_FUL+= StaticAnalyzer/Frontend/ModelConsumer.cpp
SRCS_FUL+= StaticAnalyzer/Frontend/ModelInjector.cpp
SRCS_MIN+= Tooling/ArgumentsAdjusters.cpp
SRCS_MIN+= Tooling/CommonOptionsParser.cpp
SRCS_MIN+= Tooling/CompilationDatabase.cpp
SRCS_MIN+= Tooling/Core/Replacement.cpp
SRCS_MIN+= Tooling/FileMatchTrie.cpp
SRCS_EXT+= Tooling/Inclusions/HeaderIncludes.cpp
SRCS_EXT+= Tooling/Inclusions/IncludeStyle.cpp
SRCS_MIN+= Tooling/JSONCompilationDatabase.cpp
SRCS_MIN+= Tooling/Refactoring.cpp
SRCS_MIN+= Tooling/RefactoringCallbacks.cpp
SRCS_MIN+= Tooling/Tooling.cpp
SRCS_ALL+= ${SRCS_MIN}
.if ${MK_CLANG_EXTRAS} != "no" || ${MK_CLANG_FORMAT} != "no"
SRCS_ALL+= ${SRCS_EXT}
.endif
.if ${MK_CLANG_FULL} != "no"
SRCS_ALL+= ${SRCS_FUL}
.endif
.if ${MK_LLDB} != "no"
SRCS_ALL+= ${SRCS_LDB}
.endif
SRCS+= ${SRCS_ALL:O}
clang/AST/AbstractBasicReader.inc: \
${CLANG_SRCS}/include/clang/AST/PropertiesBase.td
${CLANG_TBLGEN} -gen-clang-basic-reader \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/AST/PropertiesBase.td
TGHDRS+= clang/AST/AbstractBasicReader.inc
clang/AST/AbstractBasicWriter.inc: \
${CLANG_SRCS}/include/clang/AST/PropertiesBase.td
${CLANG_TBLGEN} -gen-clang-basic-writer \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/AST/PropertiesBase.td
TGHDRS+= clang/AST/AbstractBasicWriter.inc
clang/AST/AbstractTypeReader.inc: \
${CLANG_SRCS}/include/clang/AST/TypeProperties.td
${CLANG_TBLGEN} -gen-clang-type-reader \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/AST/TypeProperties.td
TGHDRS+= clang/AST/AbstractTypeReader.inc
clang/AST/AbstractTypeWriter.inc: \
${CLANG_SRCS}/include/clang/AST/TypeProperties.td
${CLANG_TBLGEN} -gen-clang-type-writer \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/AST/TypeProperties.td
TGHDRS+= clang/AST/AbstractTypeWriter.inc
clang/AST/AttrImpl.inc: ${CLANG_SRCS}/include/clang/Basic/Attr.td
${CLANG_TBLGEN} -gen-clang-attr-impl \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/Attr.td
TGHDRS+= clang/AST/AttrImpl.inc
clang/AST/AttrNodeTraverse.inc: ${CLANG_SRCS}/include/clang/Basic/Attr.td
${CLANG_TBLGEN} -gen-clang-attr-node-traverse \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/Attr.td
TGHDRS+= clang/AST/AttrNodeTraverse.inc
clang/AST/AttrTextNodeDump.inc: ${CLANG_SRCS}/include/clang/Basic/Attr.td
${CLANG_TBLGEN} -gen-clang-attr-text-node-dump \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/Attr.td
TGHDRS+= clang/AST/AttrTextNodeDump.inc
clang/AST/AttrVisitor.inc: ${CLANG_SRCS}/include/clang/Basic/Attr.td
${CLANG_TBLGEN} -gen-clang-attr-ast-visitor \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/Attr.td
TGHDRS+= clang/AST/AttrVisitor.inc
clang/AST/Attrs.inc: ${CLANG_SRCS}/include/clang/Basic/Attr.td
${CLANG_TBLGEN} -gen-clang-attr-classes \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/Attr.td
TGHDRS+= clang/AST/Attrs.inc
clang/AST/CommentCommandInfo.inc: \
${CLANG_SRCS}/include/clang/AST/CommentCommands.td
${CLANG_TBLGEN} -gen-clang-comment-command-info \
-d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/AST/CommentCommands.td
TGHDRS+= clang/AST/CommentCommandInfo.inc
clang/AST/CommentCommandList.inc: \
${CLANG_SRCS}/include/clang/AST/CommentCommands.td
${CLANG_TBLGEN} -gen-clang-comment-command-list \
-d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/AST/CommentCommands.td
TGHDRS+= clang/AST/CommentCommandList.inc
clang/AST/CommentHTMLNamedCharacterReferences.inc: \
${CLANG_SRCS}/include/clang/AST/CommentHTMLNamedCharacterReferences.td
${CLANG_TBLGEN} -gen-clang-comment-html-named-character-references \
-d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/AST/CommentHTMLNamedCharacterReferences.td
TGHDRS+= clang/AST/CommentHTMLNamedCharacterReferences.inc
clang/AST/CommentHTMLTags.inc: \
${CLANG_SRCS}/include/clang/AST/CommentHTMLTags.td
${CLANG_TBLGEN} -gen-clang-comment-html-tags \
-d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/AST/CommentHTMLTags.td
TGHDRS+= clang/AST/CommentHTMLTags.inc
clang/AST/CommentHTMLTagsProperties.inc: \
${CLANG_SRCS}/include/clang/AST/CommentHTMLTags.td
${CLANG_TBLGEN} -gen-clang-comment-html-tags-properties \
-d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/AST/CommentHTMLTags.td
TGHDRS+= clang/AST/CommentHTMLTagsProperties.inc
clang/AST/CommentNodes.inc: ${CLANG_SRCS}/include/clang/Basic/CommentNodes.td
${CLANG_TBLGEN} -gen-clang-comment-nodes \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/CommentNodes.td
TGHDRS+= clang/AST/CommentNodes.inc
clang/AST/DeclNodes.inc: ${CLANG_SRCS}/include/clang/Basic/DeclNodes.td
${CLANG_TBLGEN} -gen-clang-decl-nodes \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/DeclNodes.td
TGHDRS+= clang/AST/DeclNodes.inc
clang/AST/StmtDataCollectors.inc: \
${CLANG_SRCS}/include/clang/AST/StmtDataCollectors.td
${CLANG_TBLGEN} -gen-clang-data-collectors \
-d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/AST/StmtDataCollectors.td
TGHDRS+= clang/AST/StmtDataCollectors.inc
clang/AST/StmtNodes.inc: ${CLANG_SRCS}/include/clang/Basic/StmtNodes.td
${CLANG_TBLGEN} -gen-clang-stmt-nodes \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/StmtNodes.td
TGHDRS+= clang/AST/StmtNodes.inc
clang/AST/TypeNodes.inc: ${CLANG_SRCS}/include/clang/Basic/TypeNodes.td
${CLANG_TBLGEN} -gen-clang-type-nodes \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/TypeNodes.td
TGHDRS+= clang/AST/TypeNodes.inc
clang/Basic/AttrHasAttributeImpl.inc: ${CLANG_SRCS}/include/clang/Basic/Attr.td
${CLANG_TBLGEN} -gen-clang-attr-has-attribute-impl \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/Attr.td
TGHDRS+= clang/Basic/AttrHasAttributeImpl.inc
clang/Basic/AttrList.inc: ${CLANG_SRCS}/include/clang/Basic/Attr.td
${CLANG_TBLGEN} -gen-clang-attr-list \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/Attr.td
TGHDRS+= clang/Basic/AttrList.inc
clang/Basic/AttrSubMatchRulesList.inc: ${CLANG_SRCS}/include/clang/Basic/Attr.td
${CLANG_TBLGEN} -gen-clang-attr-subject-match-rule-list \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/Attr.td
TGHDRS+= clang/Basic/AttrSubMatchRulesList.inc
.for hdr in \
AST Analysis Comment Common CrossTU Driver Frontend Lex Parse \
Refactoring Sema Serialization SemaSerialization
clang/Basic/Diagnostic${hdr}Kinds.inc: \
${CLANG_SRCS}/include/clang/Basic/Diagnostic.td
${CLANG_TBLGEN} -gen-clang-diags-defs -clang-component=${hdr} \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/Diagnostic.td
TGHDRS+= clang/Basic/Diagnostic${hdr}Kinds.inc
.endfor
clang/Basic/DiagnosticGroups.inc: \
${CLANG_SRCS}/include/clang/Basic/Diagnostic.td
${CLANG_TBLGEN} -gen-clang-diag-groups \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/Diagnostic.td
TGHDRS+= clang/Basic/DiagnosticGroups.inc
clang/Basic/DiagnosticIndexName.inc: \
${CLANG_SRCS}/include/clang/Basic/Diagnostic.td
${CLANG_TBLGEN} -gen-clang-diags-index-name \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/Diagnostic.td
TGHDRS+= clang/Basic/DiagnosticIndexName.inc
clang/Basic/arm_fp16.inc: ${CLANG_SRCS}/include/clang/Basic/arm_fp16.td
${CLANG_TBLGEN} -gen-arm-neon-sema \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/arm_fp16.td
TGHDRS+= clang/Basic/arm_fp16.inc
clang/Basic/arm_neon.inc: ${CLANG_SRCS}/include/clang/Basic/arm_neon.td
${CLANG_TBLGEN} -gen-arm-neon-sema \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/arm_neon.td
TGHDRS+= clang/Basic/arm_neon.inc
clang/Basic/arm_cde_builtins.inc: ${CLANG_SRCS}/include/clang/Basic/arm_cde.td
${CLANG_TBLGEN} -gen-arm-cde-builtin-def \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/arm_cde.td
TGHDRS+= clang/Basic/arm_cde_builtins.inc
clang/Basic/arm_cde_builtin_aliases.inc: \
${CLANG_SRCS}/include/clang/Basic/arm_cde.td
${CLANG_TBLGEN} -gen-arm-cde-builtin-aliases \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/arm_cde.td
TGHDRS+= clang/Basic/arm_cde_builtin_aliases.inc
clang/Basic/arm_cde_builtin_cg.inc: ${CLANG_SRCS}/include/clang/Basic/arm_cde.td
${CLANG_TBLGEN} -gen-arm-cde-builtin-codegen \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/arm_cde.td
TGHDRS+= clang/Basic/arm_cde_builtin_cg.inc
clang/Basic/arm_cde_builtin_sema.inc: \
${CLANG_SRCS}/include/clang/Basic/arm_cde.td
${CLANG_TBLGEN} -gen-arm-cde-builtin-sema \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/arm_cde.td
TGHDRS+= clang/Basic/arm_cde_builtin_sema.inc
clang/Basic/arm_mve_builtins.inc: ${CLANG_SRCS}/include/clang/Basic/arm_mve.td
${CLANG_TBLGEN} -gen-arm-mve-builtin-def \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/arm_mve.td
TGHDRS+= clang/Basic/arm_mve_builtins.inc
clang/Basic/arm_mve_builtin_aliases.inc: \
${CLANG_SRCS}/include/clang/Basic/arm_mve.td
${CLANG_TBLGEN} -gen-arm-mve-builtin-aliases \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/arm_mve.td
TGHDRS+= clang/Basic/arm_mve_builtin_aliases.inc
clang/Basic/arm_mve_builtin_cg.inc: ${CLANG_SRCS}/include/clang/Basic/arm_mve.td
${CLANG_TBLGEN} -gen-arm-mve-builtin-codegen \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/arm_mve.td
TGHDRS+= clang/Basic/arm_mve_builtin_cg.inc
clang/Basic/arm_mve_builtin_sema.inc: \
${CLANG_SRCS}/include/clang/Basic/arm_mve.td
${CLANG_TBLGEN} -gen-arm-mve-builtin-sema \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/arm_mve.td
TGHDRS+= clang/Basic/arm_mve_builtin_sema.inc
clang/Basic/arm_sve_builtins.inc: ${CLANG_SRCS}/include/clang/Basic/arm_sve.td
${CLANG_TBLGEN} -gen-arm-sve-builtins \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/arm_sve.td
TGHDRS+= clang/Basic/arm_sve_builtins.inc
clang/Basic/arm_sve_builtin_cg.inc: ${CLANG_SRCS}/include/clang/Basic/arm_sve.td
${CLANG_TBLGEN} -gen-arm-sve-builtin-codegen \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/arm_sve.td
TGHDRS+= clang/Basic/arm_sve_builtin_cg.inc
clang/Basic/arm_sve_sema_rangechecks.inc: \
${CLANG_SRCS}/include/clang/Basic/arm_sve.td
${CLANG_TBLGEN} -gen-arm-sve-sema-rangechecks \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/arm_sve.td
TGHDRS+= clang/Basic/arm_sve_sema_rangechecks.inc
clang/Basic/arm_sve_typeflags.inc: \
${CLANG_SRCS}/include/clang/Basic/arm_sve.td
${CLANG_TBLGEN} -gen-arm-sve-typeflags \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/arm_sve.td
TGHDRS+= clang/Basic/arm_sve_typeflags.inc
clang/Basic/riscv_vector_builtins.inc: \
${CLANG_SRCS}/include/clang/Basic/riscv_vector.td
${CLANG_TBLGEN} -gen-riscv-vector-builtins \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/riscv_vector.td
TGHDRS+= clang/Basic/riscv_vector_builtins.inc
clang/Basic/riscv_vector_builtin_cg.inc: \
${CLANG_SRCS}/include/clang/Basic/riscv_vector.td
${CLANG_TBLGEN} -gen-riscv-vector-builtin-codegen \
-I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/$/.d/} \
-o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/riscv_vector.td
TGHDRS+= clang/Basic/riscv_vector_builtin_cg.inc
clang/Driver/Options.inc: ${CLANG_SRCS}/include/clang/Driver/Options.td
${LLVM_TBLGEN} -gen-opt-parser-defs \
-I ${LLVM_SRCS}/include -I ${CLANG_SRCS}/include/clang/Driver \
-d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Driver/Options.td
TGHDRS+= clang/Driver/Options.inc
clang/Parse/AttrParserStringSwitches.inc: \
${CLANG_SRCS}/include/clang/Basic/Attr.td
${CLANG_TBLGEN} -gen-clang-attr-parser-string-switches \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/Attr.td
TGHDRS+= clang/Parse/AttrParserStringSwitches.inc
clang/Parse/AttrSubMatchRulesParserStringSwitches.inc: \
${CLANG_SRCS}/include/clang/Basic/Attr.td
${CLANG_TBLGEN} -gen-clang-attr-subject-match-rules-parser-string-switches \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/Attr.td
TGHDRS+= clang/Parse/AttrSubMatchRulesParserStringSwitches.inc
clang/Sema/AttrParsedAttrImpl.inc: ${CLANG_SRCS}/include/clang/Basic/Attr.td
${CLANG_TBLGEN} -gen-clang-attr-parsed-attr-impl \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/Attr.td
TGHDRS+= clang/Sema/AttrParsedAttrImpl.inc
clang/Sema/AttrParsedAttrKinds.inc: ${CLANG_SRCS}/include/clang/Basic/Attr.td
${CLANG_TBLGEN} -gen-clang-attr-parsed-attr-kinds \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/Attr.td
TGHDRS+= clang/Sema/AttrParsedAttrKinds.inc
clang/Sema/AttrParsedAttrList.inc: ${CLANG_SRCS}/include/clang/Basic/Attr.td
${CLANG_TBLGEN} -gen-clang-attr-parsed-attr-list \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/Attr.td
TGHDRS+= clang/Sema/AttrParsedAttrList.inc
clang/Sema/AttrSpellingListIndex.inc: ${CLANG_SRCS}/include/clang/Basic/Attr.td
${CLANG_TBLGEN} -gen-clang-attr-spelling-index \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/Attr.td
TGHDRS+= clang/Sema/AttrSpellingListIndex.inc
clang/Sema/AttrTemplateInstantiate.inc: \
${CLANG_SRCS}/include/clang/Basic/Attr.td
${CLANG_TBLGEN} -gen-clang-attr-template-instantiate \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/Attr.td
TGHDRS+= clang/Sema/AttrTemplateInstantiate.inc
clang/Serialization/AttrPCHRead.inc: ${CLANG_SRCS}/include/clang/Basic/Attr.td
${CLANG_TBLGEN} -gen-clang-attr-pch-read \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/Attr.td
TGHDRS+= clang/Serialization/AttrPCHRead.inc
clang/Serialization/AttrPCHWrite.inc: ${CLANG_SRCS}/include/clang/Basic/Attr.td
${CLANG_TBLGEN} -gen-clang-attr-pch-write \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/Basic/Attr.td
TGHDRS+= clang/Serialization/AttrPCHWrite.inc
clang/StaticAnalyzer/Checkers/Checkers.inc: \
${CLANG_SRCS}/include/clang/StaticAnalyzer/Checkers/Checkers.td
${CLANG_TBLGEN} -gen-clang-sa-checkers \
-I ${CLANG_SRCS}/include/clang/StaticAnalyzer/Checkers \
-d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/include/clang/StaticAnalyzer/Checkers/Checkers.td
TGHDRS+= clang/StaticAnalyzer/Checkers/Checkers.inc
Opcodes.inc: ${CLANG_SRCS}/lib/AST/Interp/Opcodes.td
${CLANG_TBLGEN} -gen-clang-opcodes \
-I ${CLANG_SRCS}/include -d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/lib/AST/Interp/Opcodes.td
TGHDRS+= Opcodes.inc
OpenCLBuiltins.inc: ${CLANG_SRCS}/lib/Sema/OpenCLBuiltins.td
${CLANG_TBLGEN} -gen-clang-opencl-builtins \
-d ${.TARGET:C/$/.d/} -o ${.TARGET} \
${CLANG_SRCS}/lib/Sema/OpenCLBuiltins.td
TGHDRS+= OpenCLBuiltins.inc
DEPENDFILES+= ${TGHDRS:C/$/.d/}
DPSRCS+= ${TGHDRS}
CLEANFILES+= ${TGHDRS} ${TGHDRS:C/$/.d/}
.include "../clang.build.mk"
INTERNALLIB=
.include <bsd.lib.mk>
diff --git a/lib/clang/liblldb/LLDBWrapLua.cpp b/lib/clang/liblldb/LLDBWrapLua.cpp
index 215549bd8414..7ad131ad9b62 100644
--- a/lib/clang/liblldb/LLDBWrapLua.cpp
+++ b/lib/clang/liblldb/LLDBWrapLua.cpp
@@ -1,73547 +1,73540 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 4.0.2
*
* This file is not intended to be easily readable and contains a number of
* coding conventions designed to improve portability and efficiency. Do not make
* changes to this file unless you know what you are doing--modify the SWIG
* interface file instead.
* ----------------------------------------------------------------------------- */
#ifndef SWIGLUA
#define SWIGLUA
#endif
#define SWIG_LUA_TARGET SWIG_LUA_FLAVOR_LUA
#define SWIG_LUA_MODULE_GLOBAL
#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
struct SwigMovePointer {
T *ptr;
SwigMovePointer(T *p) : ptr(p) { }
~SwigMovePointer() { delete ptr; }
SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
} pointer;
SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
SwigValueWrapper() : pointer(0) { }
SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
operator T&() const { return *pointer.ptr; }
T *operator&() { return pointer.ptr; }
};
template <typename T> T SwigValueInit() {
return T();
}
#endif
/* -----------------------------------------------------------------------------
* This section contains generic SWIG labels for method/variable
* declarations/attributes, and other compiler dependent labels.
* ----------------------------------------------------------------------------- */
/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
# define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
# define SWIGTEMPLATEDISAMBIGUATOR template
# else
# define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif
/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
# define SWIGINLINE inline
# else
# define SWIGINLINE
# endif
#endif
/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
# elif defined(__ICC)
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
#endif
#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
# else
# define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif
/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif
/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif
/* exporting methods */
#if defined(__GNUC__)
# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
# ifndef GCC_HASCLASSVISIBILITY
# define GCC_HASCLASSVISIBILITY
# endif
# endif
#endif
#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# if defined(STATIC_LINKED)
# define SWIGEXPORT
# else
# define SWIGEXPORT __declspec(dllexport)
# endif
# else
# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
# define SWIGEXPORT __attribute__ ((visibility("default")))
# else
# define SWIGEXPORT
# endif
# endif
#endif
/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# define SWIGSTDCALL __stdcall
# else
# define SWIGSTDCALL
# endif
#endif
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif
/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif
/* Intel's compiler complains if a variable which was never initialised is
* cast to void, which is a common idiom which we use to indicate that we
* are aware a variable isn't used. So we just silence that warning.
* See: https://github.com/swig/swig/issues/192 for more discussion.
*/
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif
/* -----------------------------------------------------------------------------
* swigrun.swg
*
* This file contains generic C API SWIG runtime support for pointer
* type checking.
* ----------------------------------------------------------------------------- */
/* This should only be incremented when either the layout of swig_type_info changes,
or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif
/*
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
creating a static or dynamic library from the SWIG runtime code.
In 99.9% of the cases, SWIG just needs to declare them as 'static'.
But only do this if strictly necessary, ie, if you have problems
with your compiler or suchlike.
*/
#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif
#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif
/* Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif
/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN 0x1
#define SWIG_CAST_NEW_MEMORY 0x2
#define SWIG_POINTER_NO_NULL 0x4
/* Flags for new pointer objects */
#define SWIG_POINTER_OWN 0x1
/*
Flags/methods for returning states.
The SWIG conversion methods, as ConvertPtr, return an integer
that tells if the conversion was successful or not. And if not,
an error code can be returned (see swigerrors.swg for the codes).
Use the following macros/flags to set or process the returning
states.
In old versions of SWIG, code such as the following was usually written:
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
// success code
} else {
//fail code
}
Now you can be more explicit:
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
if (SWIG_IsOK(res)) {
// success code
} else {
// fail code
}
which is the same really, but now you can also do
Type *ptr;
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
if (SWIG_IsOK(res)) {
// success code
if (SWIG_IsNewObj(res) {
...
delete *ptr;
} else {
...
}
} else {
// fail code
}
I.e., now SWIG_ConvertPtr can return new objects and you can
identify the case and take care of the deallocation. Of course that
also requires SWIG_ConvertPtr to return new result values, such as
int SWIG_ConvertPtr(obj, ptr,...) {
if (<obj is ok>) {
if (<need new object>) {
*ptr = <ptr to new allocated object>;
return SWIG_NEWOBJ;
} else {
*ptr = <ptr to old object>;
return SWIG_OLDOBJ;
}
} else {
return SWIG_BADOBJ;
}
}
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
SWIG errors code.
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
allows to return the 'cast rank', for example, if you have this
int food(double)
int fooi(int);
and you call
food(1) // cast rank '1' (1 -> 1.0)
fooi(1) // cast rank '0'
just use the SWIG_AddCast()/SWIG_CheckState()
*/
#define SWIG_OK (0)
#define SWIG_ERROR (-1)
#define SWIG_IsOK(r) (r >= 0)
#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ (SWIG_ERROR)
#define SWIG_OLDOBJ (SWIG_OK)
#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del mask methods */
#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
# ifndef SWIG_TypeRank
# define SWIG_TypeRank unsigned long
# endif
# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
# define SWIG_MAXCASTRANK (2)
# endif
# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
# define SWIG_AddCast(r) (r)
# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif
#include <string.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);
/* Structure to store information on one type */
typedef struct swig_type_info {
const char *name; /* mangled name of this type */
const char *str; /* human readable name of this type */
swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
struct swig_cast_info *cast; /* linked list of types that can cast into this type */
void *clientdata; /* language specific type data */
int owndata; /* flag if the structure owns the clientdata */
} swig_type_info;
/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
swig_type_info *type; /* pointer to type that is equivalent to this type */
swig_converter_func converter; /* function to cast the void pointers */
struct swig_cast_info *next; /* pointer to next cast in linked list */
struct swig_cast_info *prev; /* pointer to the previous cast */
} swig_cast_info;
/* Structure used to store module information
* Each module generates one structure like this, and the runtime collects
* all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
size_t size; /* Number of types in this module */
struct swig_module_info *next; /* Pointer to next element in circularly linked list */
swig_type_info **type_initial; /* Array of initially generated type structures */
swig_cast_info **cast_initial; /* Array of initially generated casting structures */
void *clientdata; /* Language specific module data */
} swig_module_info;
/*
Compare two type names skipping the space characters, therefore
"char*" == "char *" and "Class<int>" == "Class<int >", etc.
Return 0 when the two name types are equivalent, as in
strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
const char *f2, const char *l2) {
for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
while ((*f1 == ' ') && (f1 != l1)) ++f1;
while ((*f2 == ' ') && (f2 != l2)) ++f2;
if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
}
return (int)((l1 - f1) - (l2 - f2));
}
/*
Check type equivalence in a name list like <name1>|<name2>|...
Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
int equiv = 1;
const char* te = tb + strlen(tb);
const char* ne = nb;
while (equiv != 0 && *ne) {
for (nb = ne; *ne; ++ne) {
if (*ne == '|') break;
}
equiv = SWIG_TypeNameComp(nb, ne, tb, te);
if (*ne) ++ne;
}
return equiv;
}
/*
Check type equivalence in a name list like <name1>|<name2>|...
Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}
/*
Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (strcmp(iter->type->name, c) == 0) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (iter->type == from) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}
/*
Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
swig_type_info *lastty = ty;
if (!ty || !ty->dcast) return ty;
while (ty && (ty->dcast)) {
ty = (*ty->dcast)(ptr);
if (ty) lastty = ty;
}
return lastty;
}
/*
Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
return ty->name;
}
/*
Return the pretty name associated with this type,
that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
/* The "str" field contains the equivalent pretty names of the
type, separated by vertical-bar characters. We choose
to print the last name, as it is often (?) the most
specific. */
if (!type) return NULL;
if (type->str != NULL) {
const char *last_name = type->str;
const char *s;
for (s = type->str; *s; s++)
if (*s == '|') last_name = s+1;
return last_name;
}
else
return type->name;
}
/*
Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
swig_cast_info *cast = ti->cast;
/* if (ti->clientdata == clientdata) return; */
ti->clientdata = clientdata;
while (cast) {
if (!cast->converter) {
swig_type_info *tc = cast->type;
if (!tc->clientdata) {
SWIG_TypeClientData(tc, clientdata);
}
}
cast = cast->next;
}
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
SWIG_TypeClientData(ti, clientdata);
ti->owndata = 1;
}
/*
Search for a swig_type_info structure only by mangled name
Search is a O(log #types)
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
swig_module_info *iter = start;
do {
if (iter->size) {
size_t l = 0;
size_t r = iter->size - 1;
do {
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
size_t i = (l + r) >> 1;
const char *iname = iter->types[i]->name;
if (iname) {
int compare = strcmp(name, iname);
if (compare == 0) {
return iter->types[i];
} else if (compare < 0) {
if (i) {
r = i - 1;
} else {
break;
}
} else if (compare > 0) {
l = i + 1;
}
} else {
break; /* should never happen */
}
} while (l <= r);
}
iter = iter->next;
} while (iter != end);
return 0;
}
/*
Search for a swig_type_info structure for either a mangled name or a human readable name.
It first searches the mangled names of the types, which is a O(log #types)
If a type is not found it then searches the human readable names, which is O(#types).
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
/* STEP 1: Search the name field using binary search */
swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
if (ret) {
return ret;
} else {
/* STEP 2: If the type hasn't been found, do a complete search
of the str field (the human readable name) */
swig_module_info *iter = start;
do {
size_t i = 0;
for (; i < iter->size; ++i) {
if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
return iter->types[i];
}
iter = iter->next;
} while (iter != end);
}
/* neither found a match */
return 0;
}
/*
Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
static const char hex[17] = "0123456789abcdef";
const unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
return c;
}
/*
Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
char d = *(c++);
unsigned char uu;
if ((d >= '0') && (d <= '9'))
uu = (unsigned char)((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
uu = (unsigned char)((d - ('a'-10)) << 4);
else
return (char *) 0;
d = *(c++);
if ((d >= '0') && (d <= '9'))
uu |= (unsigned char)(d - '0');
else if ((d >= 'a') && (d <= 'f'))
uu |= (unsigned char)(d - ('a'-10));
else
return (char *) 0;
*u = uu;
}
return c;
}
/*
Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
char *r = buff;
if ((2*sizeof(void *) + 2) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,&ptr,sizeof(void *));
if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
strcpy(r,name);
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
*ptr = (void *) 0;
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sizeof(void *));
}
SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
char *r = buff;
size_t lname = (name ? strlen(name) : 0);
if ((2*sz + 2 + lname) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,ptr,sz);
if (lname) {
strncpy(r,name,lname+1);
} else {
*r = 0;
}
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
memset(ptr,0,sz);
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sz);
}
#ifdef __cplusplus
}
#endif
/* Errors in SWIG */
#define SWIG_UnknownError -1
#define SWIG_IOError -2
#define SWIG_RuntimeError -3
#define SWIG_IndexError -4
#define SWIG_TypeError -5
#define SWIG_DivisionByZero -6
#define SWIG_OverflowError -7
#define SWIG_SyntaxError -8
#define SWIG_ValueError -9
#define SWIG_SystemError -10
#define SWIG_AttributeError -11
#define SWIG_MemoryError -12
#define SWIG_NullReferenceError -13
/* -----------------------------------------------------------------------------
* luarun.swg
*
* This file contains the runtime support for Lua modules
* and includes code for managing global variables and pointer
* type checking.
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#endif
#include "lua.h"
#include "lauxlib.h"
#include <stdlib.h> /* for malloc */
#include <assert.h> /* for a few sanity tests */
/* -----------------------------------------------------------------------------
* Lua flavors
* ----------------------------------------------------------------------------- */
#define SWIG_LUA_FLAVOR_LUA 1
#define SWIG_LUA_FLAVOR_ELUA 2
#define SWIG_LUA_FLAVOR_ELUAC 3
#if !defined(SWIG_LUA_TARGET)
# error SWIG_LUA_TARGET not defined
#endif
#if defined(SWIG_LUA_ELUA_EMULATE)
struct swig_elua_entry;
typedef struct swig_elua_key {
int type;
union {
const char* strkey;
lua_Number numkey;
} key;
} swig_elua_key;
typedef struct swig_elua_val {
int type;
union {
lua_Number number;
const struct swig_elua_entry *table;
const char *string;
lua_CFunction function;
struct {
char member;
long lvalue;
void *pvalue;
swig_type_info **ptype;
} userdata;
} value;
} swig_elua_val;
typedef struct swig_elua_entry {
swig_elua_key key;
swig_elua_val value;
} swig_elua_entry;
#define LSTRKEY(x) {LUA_TSTRING, {.strkey = x} }
#define LNUMKEY(x) {LUA_TNUMBER, {.numkey = x} }
#define LNILKEY {LUA_TNIL, {.strkey = 0} }
#define LNUMVAL(x) {LUA_TNUMBER, {.number = x} }
#define LFUNCVAL(x) {LUA_TFUNCTION, {.function = x} }
#define LROVAL(x) {LUA_TTABLE, {.table = x} }
#define LNILVAL {LUA_TNIL, {.string = 0} }
#define LSTRVAL(x) {LUA_TSTRING, {.string = x} }
#define LUA_REG_TYPE swig_elua_entry
#define SWIG_LUA_ELUA_EMUL_METATABLE_KEY "__metatable"
#define lua_pushrotable(L,p)\
lua_newtable(L);\
assert(p);\
SWIG_Lua_elua_emulate_register(L,(swig_elua_entry*)(p));
#define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\
LSTRKEY(B), {LUA_TUSERDATA, { .userdata={0,0,(void*)(C),&D} } }
#define SWIG_LUA_CONSTTAB_BINARY(B,S,C,D)\
LSTRKEY(B), {LUA_TUSERDATA, { .userdata={1,S,(void*)(C),&D} } }
#endif
#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
# define SWIG_LUA_CONSTTAB_INT(B, C) LSTRKEY(B), LNUMVAL(C)
# define SWIG_LUA_CONSTTAB_FLOAT(B, C) LSTRKEY(B), LNUMVAL(C)
# define SWIG_LUA_CONSTTAB_STRING(B, C) LSTRKEY(B), LSTRVAL(C)
# define SWIG_LUA_CONSTTAB_CHAR(B, C) LSTRKEY(B), LNUMVAL(C)
/* Those two types of constants are not supported in elua */
#ifndef SWIG_LUA_CONSTTAB_POINTER
#warning eLua does not support pointers as constants. By default, nil will be used as value
#define SWIG_LUA_CONSTTAB_POINTER(B,C,D) LSTRKEY(B), LNILVAL
#endif
#ifndef SWIG_LUA_CONSTTAB_BINARY
#warning eLua does not support pointers to member as constants. By default, nil will be used as value
#define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D) LSTRKEY(B), LNILVAL
#endif
#else /* SWIG_LUA_FLAVOR_LUA */
# define SWIG_LUA_CONSTTAB_INT(B, C) SWIG_LUA_INT, (char *)B, (long)C, 0, 0, 0
# define SWIG_LUA_CONSTTAB_FLOAT(B, C) SWIG_LUA_FLOAT, (char *)B, 0, (double)C, 0, 0
# define SWIG_LUA_CONSTTAB_STRING(B, C) SWIG_LUA_STRING, (char *)B, 0, 0, (void *)C, 0
# define SWIG_LUA_CONSTTAB_CHAR(B, C) SWIG_LUA_CHAR, (char *)B, (long)C, 0, 0, 0
# define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\
SWIG_LUA_POINTER, (char *)B, 0, 0, (void *)C, &D
# define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D)\
SWIG_LUA_BINARY, (char *)B, S, 0, (void *)C, &D
#endif
#ifndef SWIG_LUA_ELUA_EMULATE
#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
# define LRO_STRVAL(v) {{.p = (char *) v}, LUA_TSTRING}
# define LSTRVAL LRO_STRVAL
#endif
#endif /* SWIG_LUA_ELUA_EMULATE*/
#ifndef SWIG_LUA_ELUA_EMULATE
#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
#ifndef MIN_OPT_LEVEL
#define MIN_OPT_LEVEL 2
#endif
#include "lrodefs.h"
#include "lrotable.h"
#endif
#endif /* SWIG_LUA_ELUA_EMULATE*/
/* -----------------------------------------------------------------------------
* compatibility defines
* ----------------------------------------------------------------------------- */
/* History of Lua C API length functions: In Lua 5.0 (and before?)
there was "lua_strlen". In Lua 5.1, this was renamed "lua_objlen",
but a compatibility define of "lua_strlen" was added. In Lua 5.2,
this function was again renamed, to "lua_rawlen" (to emphasize that
it doesn't call the "__len" metamethod), and the compatibility
define of lua_strlen was removed. All SWIG uses have been updated
to "lua_rawlen", and we add our own defines of that here for older
versions of Lua. */
#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501
# define lua_rawlen lua_strlen
#elif LUA_VERSION_NUM == 501
# define lua_rawlen lua_objlen
#endif
/* lua_pushglobaltable is the recommended "future-proof" way to get
the global table for Lua 5.2 and later. Here we define
lua_pushglobaltable ourselves for Lua versions before 5.2. */
#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
# define lua_pushglobaltable(L) lua_pushvalue(L, LUA_GLOBALSINDEX)
#endif
/* lua_absindex was introduced in Lua 5.2 */
#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
# define lua_absindex(L,i) ((i)>0 || (i) <= LUA_REGISTRYINDEX ? (i) : lua_gettop(L) + (i) + 1)
#endif
/* lua_rawsetp was introduced in Lua 5.2 */
#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
#define lua_rawsetp(L,index,ptr)\
lua_pushlightuserdata(L,(void*)(ptr));\
lua_insert(L,-2);\
lua_rawset(L,index);
#define lua_rawgetp(L,index,ptr)\
lua_pushlightuserdata(L,(void*)(ptr));\
lua_rawget(L,index);
#endif
/* --------------------------------------------------------------------------
* Helper functions for error handling
* -------------------------------------------------------------------------- */
/* Push the string STR on the Lua stack, like lua_pushstring, but
prefixed with the location of the innermost Lua call-point
(as formatted by luaL_where). */
SWIGRUNTIME void
SWIG_Lua_pusherrstring (lua_State *L, const char *str)
{
luaL_where (L, 1);
lua_pushstring (L, str);
lua_concat (L, 2);
}
/* Push a formatted string generated from FMT and following args on
the Lua stack, like lua_pushfstring, but prefixed with the
location of the innermost Lua call-point (as formatted by luaL_where). */
SWIGRUNTIME void
SWIG_Lua_pushferrstring (lua_State *L, const char *fmt, ...)
{
va_list argp;
va_start(argp, fmt);
luaL_where(L, 1);
lua_pushvfstring(L, fmt, argp);
va_end(argp);
lua_concat(L, 2);
}
/* -----------------------------------------------------------------------------
* global swig types
* ----------------------------------------------------------------------------- */
/* Constant table */
#define SWIG_LUA_INT 1
#define SWIG_LUA_FLOAT 2
#define SWIG_LUA_STRING 3
#define SWIG_LUA_POINTER 4
#define SWIG_LUA_BINARY 5
#define SWIG_LUA_CHAR 6
/* Structure for variable linking table */
typedef struct {
const char *name;
lua_CFunction get;
lua_CFunction set;
} swig_lua_var_info;
#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
typedef const LUA_REG_TYPE swig_lua_method;
typedef const LUA_REG_TYPE swig_lua_const_info;
#else /* Normal lua */
typedef luaL_Reg swig_lua_method;
/* Constant information structure */
typedef struct {
int type;
char *name;
long lvalue;
double dvalue;
void *pvalue;
swig_type_info **ptype;
} swig_lua_const_info;
#endif
typedef struct {
const char *name;
lua_CFunction getmethod;
lua_CFunction setmethod;
} swig_lua_attribute;
struct swig_lua_class;
/* Can be used to create namespaces. Currently used to wrap class static methods/variables/constants */
typedef struct swig_lua_namespace {
const char *name;
swig_lua_method *ns_methods;
swig_lua_attribute *ns_attributes;
swig_lua_const_info *ns_constants;
struct swig_lua_class **ns_classes;
struct swig_lua_namespace **ns_namespaces;
} swig_lua_namespace;
typedef struct swig_lua_class {
const char *name; /* Name that this class has in Lua */
const char *fqname; /* Fully qualified name - Scope + class name */
swig_type_info **type;
lua_CFunction constructor;
void (*destructor)(void *);
swig_lua_method *methods;
swig_lua_attribute *attributes;
swig_lua_namespace *cls_static;
swig_lua_method *metatable; /* 0 for -eluac */
struct swig_lua_class **bases;
const char **base_names;
} swig_lua_class;
/* this is the struct for wrapping all pointers in SwigLua
*/
typedef struct {
swig_type_info *type;
int own; /* 1 if owned & must be destroyed */
void *ptr;
} swig_lua_userdata;
/* this is the struct for wrapping arbitrary packed binary data
(currently it is only used for member function pointers)
the data ordering is similar to swig_lua_userdata, but it is currently not possible
to tell the two structures apart within SWIG, other than by looking at the type
*/
typedef struct {
swig_type_info *type;
int own; /* 1 if owned & must be destroyed */
char data[1]; /* arbitrary amount of data */
} swig_lua_rawdata;
/* Common SWIG API */
#define SWIG_NewPointerObj(L, ptr, type, owner) SWIG_Lua_NewPointerObj(L, (void *)ptr, type, owner)
#define SWIG_ConvertPtr(L,idx, ptr, type, flags) SWIG_Lua_ConvertPtr(L,idx,ptr,type,flags)
#define SWIG_MustGetPtr(L,idx, type,flags, argnum,fnname) SWIG_Lua_MustGetPtr(L,idx, type,flags, argnum,fnname)
/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(L, idx, ptr, sz, ty) SWIG_Lua_ConvertPacked(L, idx, ptr, sz, ty)
#define SWIG_NewMemberObj(L, ptr, sz, type) SWIG_Lua_NewPackedObj(L, ptr, sz, type)
/* Runtime API */
#define SWIG_GetModule(clientdata) SWIG_Lua_GetModule((lua_State*)(clientdata))
#define SWIG_SetModule(clientdata, pointer) SWIG_Lua_SetModule((lua_State*) (clientdata), pointer)
#define SWIG_MODULE_CLIENTDATA_TYPE lua_State*
/* Contract support */
#define SWIG_contract_assert(expr, msg) \
if (!(expr)) { SWIG_Lua_pusherrstring(L, (char *) msg); goto fail; } else
/* helper #defines */
#define SWIG_fail {goto fail;}
#define SWIG_fail_arg(func_name,argnum,type) \
{SWIG_Lua_pushferrstring(L,"Error in %s (arg %d), expected '%s' got '%s'",\
func_name,argnum,type,SWIG_Lua_typename(L,argnum));\
goto fail;}
#define SWIG_fail_ptr(func_name,argnum,type) \
SWIG_fail_arg(func_name,argnum,(type && type->str)?type->str:"void*")
#define SWIG_check_num_args(func_name,a,b) \
if (lua_gettop(L)<a || lua_gettop(L)>b) \
{SWIG_Lua_pushferrstring(L,"Error in %s expected %d..%d args, got %d",func_name,a,b,lua_gettop(L));\
goto fail;}
#define SWIG_Lua_get_table(L,n) \
(lua_pushstring(L, n), lua_rawget(L,-2))
#define SWIG_Lua_add_function(L,n,f) \
(lua_pushstring(L, n), \
lua_pushcfunction(L, f), \
lua_rawset(L,-3))
#define SWIG_Lua_add_boolean(L,n,b) \
(lua_pushstring(L, n), \
lua_pushboolean(L, b), \
lua_rawset(L,-3))
/* special helper for allowing 'nil' for usertypes */
#define SWIG_isptrtype(L,I) (lua_isuserdata(L,I) || lua_isnil(L,I))
#ifdef __cplusplus
/* Special helper for member function pointers
it gets the address, casts it, then dereferences it */
/*#define SWIG_mem_fn_as_voidptr(a) (*((char**)&(a))) */
#endif
/* storing/access of swig_module_info */
SWIGRUNTIME swig_module_info *
SWIG_Lua_GetModule(lua_State *L) {
swig_module_info *ret = 0;
lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
lua_rawget(L,LUA_REGISTRYINDEX);
if (lua_islightuserdata(L,-1))
ret=(swig_module_info*)lua_touserdata(L,-1);
lua_pop(L,1); /* tidy */
return ret;
}
SWIGRUNTIME void
SWIG_Lua_SetModule(lua_State *L, swig_module_info *module) {
/* add this all into the Lua registry: */
lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
lua_pushlightuserdata(L,(void*)module);
lua_rawset(L,LUA_REGISTRYINDEX);
}
/* -----------------------------------------------------------------------------
* global variable support code: modules
* ----------------------------------------------------------------------------- */
/* this function is called when trying to set an immutable.
default action is to print an error.
This can removed with a compile flag SWIGLUA_IGNORE_SET_IMMUTABLE */
SWIGINTERN int SWIG_Lua_set_immutable(lua_State *L)
{
/* there should be 1 param passed in: the new value */
#ifndef SWIGLUA_IGNORE_SET_IMMUTABLE
lua_pop(L,1); /* remove it */
luaL_error(L,"This variable is immutable");
#endif
return 0; /* should not return anything */
}
#ifdef SWIG_LUA_ELUA_EMULATE
SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own);
SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type);
static int swig_lua_elua_emulate_unique_key;
/* This function emulates eLua rotables behaviour. It loads a rotable definition into the usual lua table. */
SWIGINTERN void SWIG_Lua_elua_emulate_register(lua_State *L, const swig_elua_entry *table)
{
int i, table_parsed, parsed_tables_array, target_table;
assert(lua_istable(L,-1));
target_table = lua_gettop(L);
/* Get the registry where we put all parsed tables to avoid loops */
lua_rawgetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key);
if(lua_isnil(L,-1)) {
lua_pop(L,1);
lua_newtable(L);
lua_pushvalue(L,-1);
lua_rawsetp(L,LUA_REGISTRYINDEX,(void*)(&swig_lua_elua_emulate_unique_key));
}
parsed_tables_array = lua_gettop(L);
lua_pushvalue(L,target_table);
lua_rawsetp(L, parsed_tables_array, table);
table_parsed = 0;
const int SWIGUNUSED pairs_start = lua_gettop(L);
for(i = 0;table[i].key.type != LUA_TNIL || table[i].value.type != LUA_TNIL;i++)
{
const swig_elua_entry *entry = table + i;
int is_metatable = 0;
switch(entry->key.type) {
case LUA_TSTRING:
lua_pushstring(L,entry->key.key.strkey);
if(strcmp(entry->key.key.strkey, SWIG_LUA_ELUA_EMUL_METATABLE_KEY) == 0)
is_metatable = 1;
break;
case LUA_TNUMBER:
lua_pushnumber(L,entry->key.key.numkey);
break;
case LUA_TNIL:
lua_pushnil(L);
break;
default:
assert(0);
}
switch(entry->value.type) {
case LUA_TSTRING:
lua_pushstring(L,entry->value.value.string);
break;
case LUA_TNUMBER:
lua_pushnumber(L,entry->value.value.number);
break;
case LUA_TFUNCTION:
lua_pushcfunction(L,entry->value.value.function);
break;
case LUA_TTABLE:
lua_rawgetp(L,parsed_tables_array, entry->value.value.table);
table_parsed = !lua_isnil(L,-1);
if(!table_parsed) {
lua_pop(L,1); /*remove nil */
lua_newtable(L);
SWIG_Lua_elua_emulate_register(L,entry->value.value.table);
}
if(is_metatable) {
assert(lua_istable(L,-1));
lua_pushvalue(L,-1);
lua_setmetatable(L,target_table);
}
break;
case LUA_TUSERDATA:
if(entry->value.value.userdata.member)
SWIG_NewMemberObj(L,entry->value.value.userdata.pvalue,
entry->value.value.userdata.lvalue,
*(entry->value.value.userdata.ptype));
else
SWIG_NewPointerObj(L,entry->value.value.userdata.pvalue,
*(entry->value.value.userdata.ptype),0);
break;
case LUA_TNIL:
lua_pushnil(L);
break;
default:
assert(0);
}
assert(lua_gettop(L) == pairs_start + 2);
lua_rawset(L,target_table);
}
lua_pop(L,1); /* Removing parsed tables storage */
assert(lua_gettop(L) == target_table);
}
SWIGINTERN void SWIG_Lua_elua_emulate_register_clear(lua_State *L)
{
lua_pushnil(L);
lua_rawsetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key);
}
SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L);
SWIGINTERN int SWIG_Lua_emulate_elua_getmetatable(lua_State *L)
{
SWIG_check_num_args("getmetatable(SWIG eLua emulation)", 1, 1);
SWIG_Lua_get_class_registry(L);
lua_getfield(L,-1,"lua_getmetatable");
lua_remove(L,-2); /* remove the registry*/
assert(!lua_isnil(L,-1));
lua_pushvalue(L,1);
assert(lua_gettop(L) == 3); /* object | function | object again */
lua_call(L,1,1);
if(!lua_isnil(L,-1)) /*There is an ordinary metatable */
return 1;
/*if it is a table, then emulate elua behaviour - check for __metatable attribute of a table*/
assert(lua_gettop(L) == 2);
if(lua_istable(L,-2)) {
lua_pop(L,1); /*remove the nil*/
lua_getfield(L,-1, SWIG_LUA_ELUA_EMUL_METATABLE_KEY);
}
assert(lua_gettop(L) == 2);
return 1;
fail:
lua_error(L);
return 0;
}
SWIGINTERN void SWIG_Lua_emulate_elua_swap_getmetatable(lua_State *L)
{
SWIG_Lua_get_class_registry(L);
lua_pushglobaltable(L);
lua_pushstring(L,"lua_getmetatable");
lua_getfield(L,-2,"getmetatable");
assert(!lua_isnil(L,-1));
lua_rawset(L,-4);
lua_pushstring(L, "getmetatable");
lua_pushcfunction(L, SWIG_Lua_emulate_elua_getmetatable);
lua_rawset(L,-3);
lua_pop(L,2);
}
/* END OF REMOVE */
#endif
/* -----------------------------------------------------------------------------
* global variable support code: namespaces and modules (which are the same thing)
* ----------------------------------------------------------------------------- */
SWIGINTERN int SWIG_Lua_namespace_get(lua_State *L)
{
/* there should be 2 params passed in
(1) table (not the meta table)
(2) string name of the attribute
*/
assert(lua_istable(L,-2)); /* just in case */
lua_getmetatable(L,-2);
assert(lua_istable(L,-1));
SWIG_Lua_get_table(L,".get"); /* find the .get table */
assert(lua_istable(L,-1));
/* look for the key in the .get table */
lua_pushvalue(L,2); /* key */
lua_rawget(L,-2);
lua_remove(L,-2); /* stack tidy, remove .get table */
if (lua_iscfunction(L,-1))
{ /* found it so call the fn & return its value */
lua_call(L,0,1); /* 1 value in (userdata),1 out (result) */
lua_remove(L,-2); /* stack tidy, remove metatable */
return 1;
}
lua_pop(L,1); /* remove whatever was there */
/* ok, so try the .fn table */
SWIG_Lua_get_table(L,".fn"); /* find the .get table */
assert(lua_istable(L,-1)); /* just in case */
lua_pushvalue(L,2); /* key */
lua_rawget(L,-2); /* look for the fn */
lua_remove(L,-2); /* stack tidy, remove .fn table */
if (lua_isfunction(L,-1)) /* note: whether it's a C function or lua function */
{ /* found it so return the fn & let lua call it */
lua_remove(L,-2); /* stack tidy, remove metatable */
return 1;
}
lua_pop(L,1); /* remove whatever was there */
return 0;
}
SWIGINTERN int SWIG_Lua_namespace_set(lua_State *L)
{
/* there should be 3 params passed in
(1) table (not the meta table)
(2) string name of the attribute
(3) any for the new value
*/
assert(lua_istable(L,1));
lua_getmetatable(L,1); /* get the meta table */
assert(lua_istable(L,-1));
SWIG_Lua_get_table(L,".set"); /* find the .set table */
if (lua_istable(L,-1))
{
/* look for the key in the .set table */
lua_pushvalue(L,2); /* key */
lua_rawget(L,-2);
if (lua_iscfunction(L,-1))
{ /* found it so call the fn & return its value */
lua_pushvalue(L,3); /* value */
lua_call(L,1,0);
return 0;
}
lua_pop(L,1); /* remove the value */
}
lua_pop(L,1); /* remove the value .set table */
lua_pop(L,1); /* remote metatable */
lua_rawset(L,-3);
return 0;
}
#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */
SWIGINTERN void SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]); /* forward declaration */
SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn); /* forward declaration */
SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss);
/* helper function - register namespace methods and attributes into namespace */
SWIGINTERN int SWIG_Lua_add_namespace_details(lua_State *L, swig_lua_namespace *ns)
{
int i;
/* There must be namespace table (not metatable) at the top of the stack */
assert(lua_istable(L,-1));
SWIG_Lua_InstallConstants(L, ns->ns_constants);
/* add methods to the namespace/module table */
for(i=0;ns->ns_methods[i].name;i++){
SWIG_Lua_add_function(L,ns->ns_methods[i].name,ns->ns_methods[i].func);
}
lua_getmetatable(L,-1);
/* add fns */
for(i=0;ns->ns_attributes[i].name;i++){
SWIG_Lua_add_variable(L,ns->ns_attributes[i].name,ns->ns_attributes[i].getmethod,ns->ns_attributes[i].setmethod);
}
/* clear stack - remove metatble */
lua_pop(L,1);
return 0;
}
/* Register all classes in the namespace */
SWIGINTERN void SWIG_Lua_add_namespace_classes(lua_State *L, swig_lua_namespace *ns)
{
swig_lua_class **classes;
/* There must be a module/namespace table at the top of the stack */
assert(lua_istable(L,-1));
classes = ns->ns_classes;
if( classes != 0 ) {
while(*classes != 0) {
SWIG_Lua_class_register(L, *classes);
classes++;
}
}
}
/* Helper function. Creates namespace table and adds it to module table
if 'reg' is true, then will register namespace table to parent one (must be on top of the stack
when function is called).
Function always returns newly registered table on top of the stack.
*/
SWIGINTERN void SWIG_Lua_namespace_register(lua_State *L, swig_lua_namespace *ns, int reg)
{
swig_lua_namespace **sub_namespace;
/* 1 argument - table on the top of the stack */
const int SWIGUNUSED begin = lua_gettop(L);
assert(lua_istable(L,-1)); /* just in case. This is supposed to be module table or parent namespace table */
lua_checkstack(L,5);
lua_newtable(L); /* namespace itself */
lua_newtable(L); /* metatable for namespace */
/* add a table called ".get" */
lua_pushstring(L,".get");
lua_newtable(L);
lua_rawset(L,-3);
/* add a table called ".set" */
lua_pushstring(L,".set");
lua_newtable(L);
lua_rawset(L,-3);
/* add a table called ".fn" */
lua_pushstring(L,".fn");
lua_newtable(L);
lua_rawset(L,-3);
/* add accessor fns for using the .get,.set&.fn */
SWIG_Lua_add_function(L,"__index",SWIG_Lua_namespace_get);
SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_namespace_set);
lua_setmetatable(L,-2); /* set metatable */
/* Register all functions, variables etc */
SWIG_Lua_add_namespace_details(L,ns);
/* Register classes */
SWIG_Lua_add_namespace_classes(L,ns);
sub_namespace = ns->ns_namespaces;
if( sub_namespace != 0) {
while(*sub_namespace != 0) {
SWIG_Lua_namespace_register(L, *sub_namespace, 1);
lua_pop(L,1); /* removing sub-namespace table */
sub_namespace++;
}
}
if (reg) {
lua_pushstring(L,ns->name);
lua_pushvalue(L,-2);
lua_rawset(L,-4); /* add namespace to module table */
}
assert(lua_gettop(L) == begin+1);
}
#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */
/* -----------------------------------------------------------------------------
* global variable support code: classes
* ----------------------------------------------------------------------------- */
SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname);
typedef int (*swig_lua_base_iterator_func)(lua_State*,swig_type_info*, int, int *ret);
SWIGINTERN int SWIG_Lua_iterate_bases(lua_State *L, swig_type_info * SWIGUNUSED swig_type,
int first_arg, swig_lua_base_iterator_func func, int *const ret)
{
/* first_arg - position of the object in stack. Everything that is above are arguments
* and is passed to every evocation of the func */
int last_arg = lua_gettop(L);/* position of last argument */
int original_metatable = last_arg + 1;
size_t bases_count;
int result = SWIG_ERROR;
int bases_table;
(void)swig_type;
lua_getmetatable(L,first_arg);
/* initialise base search */
#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
SWIG_Lua_get_table(L,".bases");
assert(lua_istable(L,-1));
bases_count = lua_rawlen(L,-1);
bases_table = lua_gettop(L);
#else
/* In elua .bases table doesn't exist. Use table from swig_lua_class */
(void)bases_table;
assert(swig_type!=0);
swig_module_info *module=SWIG_GetModule(L);
swig_lua_class **bases= ((swig_lua_class*)(swig_type->clientdata))->bases;
const char **base_names= ((swig_lua_class*)(swig_type->clientdata))->base_names;
bases_count = 0;
for(;base_names[bases_count];
bases_count++);/* get length of bases */
#endif
if(ret)
*ret = 0;
if(bases_count>0)
{
int to_remove;
size_t i;
int j;
int subcall_last_arg;
int subcall_first_arg = lua_gettop(L) + 1;/* Here a copy of first_arg and arguments begin */
int valid = 1;
swig_type_info *base_swig_type = 0;
for(j=first_arg;j<=last_arg;j++)
lua_pushvalue(L,j);
subcall_last_arg = lua_gettop(L);
/* Trick: temporarily replacing original metatable with metatable for base class and call getter */
for(i=0;i<bases_count;i++) {
/* Iteration through class bases */
#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
lua_rawgeti(L,bases_table,i+1);
base_swig_type = 0;
if(lua_isnil(L,-1)) {
valid = 0;
lua_pop(L,1);
} else {
valid = 1;
}
#else /* In elua .bases table doesn't exist. Use table from swig_lua_class */
swig_lua_class *base_class = bases[i];
if(!base_class) {
valid = 0;
} else {
valid = 1;
SWIG_Lua_get_class_metatable(L,base_class->fqname);
base_swig_type = SWIG_TypeQueryModule(module,module,base_names[i]);
assert(base_swig_type != 0);
}
#endif
if(!valid)
continue;
assert(lua_isuserdata(L, subcall_first_arg));
assert(lua_istable(L,-1));
lua_setmetatable(L,subcall_first_arg); /* Set new metatable */
assert(lua_gettop(L) == subcall_last_arg);
result = func(L, base_swig_type,subcall_first_arg, ret); /* Forward call */
if(result != SWIG_ERROR) {
break;
}
}
/* Restore original metatable */
lua_pushvalue(L,original_metatable);
lua_setmetatable(L,first_arg);
/* Clear - remove everything between last_arg and subcall_last_arg including */
to_remove = subcall_last_arg - last_arg;
for(j=0;j<to_remove;j++)
lua_remove(L,last_arg+1);
} else {
/* Remove everything after last_arg */
lua_pop(L, lua_gettop(L) - last_arg);
}
if(ret) assert(lua_gettop(L) == last_arg + *ret);
return result;
}
/* The class.get method helper, performs the lookup of class attributes.
* It returns an error code. Number of function return values is passed inside 'ret'.
* first_arg is not used in this function because function always has 2 arguments.
*/
SWIGINTERN int SWIG_Lua_class_do_get_item(lua_State *L, swig_type_info *type, int SWIGUNUSED first_arg, int *ret)
{
/* there should be 2 params passed in
(1) userdata (not the meta table)
(2) string name of the attribute
*/
int bases_search_result;
int substack_start = lua_gettop(L)-2;
assert(first_arg == substack_start+1);
lua_checkstack(L,5);
assert(lua_isuserdata(L,-2)); /* just in case */
lua_getmetatable(L,-2); /* get the meta table */
assert(lua_istable(L,-1)); /* just in case */
/* NEW: looks for the __getitem() fn
this is a user provided get fn */
SWIG_Lua_get_table(L,"__getitem"); /* find the __getitem fn */
if (lua_iscfunction(L,-1)) /* if its there */
{ /* found it so call the fn & return its value */
lua_pushvalue(L,substack_start+1); /* the userdata */
lua_pushvalue(L,substack_start+2); /* the parameter */
lua_call(L,2,1); /* 2 value in (userdata),1 out (result) */
lua_remove(L,-2); /* stack tidy, remove metatable */
if(ret) *ret = 1;
return SWIG_OK;
}
lua_pop(L,1);
/* Remove the metatable */
lua_pop(L,1);
/* Search in base classes */
bases_search_result = SWIG_Lua_iterate_bases(L,type,substack_start+1,SWIG_Lua_class_do_get_item,ret);
return bases_search_result; /* sorry not known */
}
/* The class.get method helper, performs the lookup of class attributes.
* It returns an error code. Number of function return values is passed inside 'ret'.
* first_arg is not used in this function because function always has 2 arguments.
*/
SWIGINTERN int SWIG_Lua_class_do_get(lua_State *L, swig_type_info *type, int SWIGUNUSED first_arg, int *ret)
{
/* there should be 2 params passed in
(1) userdata (not the meta table)
(2) string name of the attribute
*/
int bases_search_result;
int substack_start = lua_gettop(L)-2;
assert(first_arg == substack_start+1);
lua_checkstack(L,5);
assert(lua_isuserdata(L,-2)); /* just in case */
lua_getmetatable(L,-2); /* get the meta table */
assert(lua_istable(L,-1)); /* just in case */
SWIG_Lua_get_table(L,".get"); /* find the .get table */
assert(lua_istable(L,-1)); /* just in case */
/* look for the key in the .get table */
lua_pushvalue(L,substack_start+2); /* key */
lua_rawget(L,-2);
lua_remove(L,-2); /* stack tidy, remove .get table */
if (lua_iscfunction(L,-1))
{ /* found it so call the fn & return its value */
lua_pushvalue(L,substack_start+1); /* the userdata */
lua_call(L,1,1); /* 1 value in (userdata),1 out (result) */
lua_remove(L,-2); /* stack tidy, remove metatable */
if(ret)
*ret = 1;
return SWIG_OK;
}
lua_pop(L,1); /* remove whatever was there */
/* ok, so try the .fn table */
SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
assert(lua_istable(L,-1)); /* just in case */
lua_pushvalue(L,substack_start+2); /* key */
lua_rawget(L,-2); /* look for the fn */
lua_remove(L,-2); /* stack tidy, remove .fn table */
if (lua_isfunction(L,-1)) /* note: if its a C function or lua function */
{ /* found it so return the fn & let lua call it */
lua_remove(L,-2); /* stack tidy, remove metatable */
if(ret)
*ret = 1;
return SWIG_OK;
}
lua_pop(L,1); /* remove whatever was there */
/* Remove the metatable */
lua_pop(L,1);
/* Search in base classes */
bases_search_result = SWIG_Lua_iterate_bases(L,type,substack_start+1,SWIG_Lua_class_do_get,ret);
return bases_search_result; /* sorry not known */
}
/* the class.get method, performs the lookup of class attributes
*/
SWIGINTERN int SWIG_Lua_class_get(lua_State *L)
{
/* there should be 2 params passed in
(1) userdata (not the meta table)
(2) string name of the attribute
*/
int result;
swig_lua_userdata *usr;
swig_type_info *type;
int ret = 0;
assert(lua_isuserdata(L,1));
usr=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */
type = usr->type;
result = SWIG_Lua_class_do_get(L,type,1,&ret);
if(result == SWIG_OK)
return ret;
result = SWIG_Lua_class_do_get_item(L,type,1,&ret);
if(result == SWIG_OK)
return ret;
return 0;
}
/* helper for the class.set method, performs the lookup of class attributes
* It returns error code. Number of function return values is passed inside 'ret'
*/
SWIGINTERN int SWIG_Lua_class_do_set(lua_State *L, swig_type_info *type, int first_arg, int *ret)
{
/* there should be 3 params passed in
(1) table (not the meta table)
(2) string name of the attribute
(3) any for the new value
*/
int bases_search_result;
int substack_start = lua_gettop(L) - 3;
lua_checkstack(L,5);
assert(lua_isuserdata(L,substack_start+1)); /* just in case */
lua_getmetatable(L,substack_start+1); /* get the meta table */
assert(lua_istable(L,-1)); /* just in case */
if(ret)
*ret = 0; /* it is setter - number of return values is always 0 */
SWIG_Lua_get_table(L,".set"); /* find the .set table */
if (lua_istable(L,-1))
{
/* look for the key in the .set table */
lua_pushvalue(L,substack_start+2); /* key */
lua_rawget(L,-2);
lua_remove(L,-2); /* tidy stack, remove .set table */
if (lua_iscfunction(L,-1))
{ /* found it so call the fn & return its value */
lua_pushvalue(L,substack_start+1); /* userdata */
lua_pushvalue(L,substack_start+3); /* value */
lua_call(L,2,0);
lua_remove(L,substack_start+4); /*remove metatable*/
return SWIG_OK;
}
lua_pop(L,1); /* remove the value */
} else {
lua_pop(L,1); /* remove the answer for .set table request*/
}
/* NEW: looks for the __setitem() fn
this is a user provided set fn */
SWIG_Lua_get_table(L,"__setitem"); /* find the fn */
if (lua_iscfunction(L,-1)) /* if its there */
{ /* found it so call the fn & return its value */
lua_pushvalue(L,substack_start+1); /* the userdata */
lua_pushvalue(L,substack_start+2); /* the parameter */
lua_pushvalue(L,substack_start+3); /* the value */
lua_call(L,3,0); /* 3 values in ,0 out */
lua_remove(L,-2); /* stack tidy, remove metatable */
return SWIG_OK;
}
lua_pop(L,1); /* remove value */
lua_pop(L,1); /* remove metatable */
/* Search among bases */
bases_search_result = SWIG_Lua_iterate_bases(L,type,first_arg,SWIG_Lua_class_do_set,ret);
if(ret)
assert(*ret == 0);
assert(lua_gettop(L) == substack_start + 3);
return bases_search_result;
}
/* This is the actual method exported to Lua. It calls SWIG_Lua_class_do_set and correctly
* handles return values.
*/
SWIGINTERN int SWIG_Lua_class_set(lua_State *L)
{
/* There should be 3 params passed in
(1) table (not the meta table)
(2) string name of the attribute
(3) any for the new value
*/
int ret = 0;
int result;
swig_lua_userdata *usr;
swig_type_info *type;
assert(lua_isuserdata(L,1));
usr=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */
type = usr->type;
result = SWIG_Lua_class_do_set(L,type,1,&ret);
if(result != SWIG_OK) {
SWIG_Lua_pushferrstring(L,"Assignment not possible. No setter/member with this name. For custom assignments implement __setitem method.");
lua_error(L);
} else {
assert(ret==0);
}
return 0;
}
/* the class.destruct method called by the interpreter */
SWIGINTERN int SWIG_Lua_class_destruct(lua_State *L)
{
/* there should be 1 params passed in
(1) userdata (not the meta table) */
swig_lua_userdata *usr;
swig_lua_class *clss;
assert(lua_isuserdata(L,-1)); /* just in case */
usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */
/* if must be destroyed & has a destructor */
if (usr->own) /* if must be destroyed */
{
clss=(swig_lua_class*)usr->type->clientdata; /* get the class */
if (clss && clss->destructor) /* there is a destroy fn */
{
clss->destructor(usr->ptr); /* bye bye */
}
}
return 0;
}
/* the class.__tostring method called by the interpreter and print */
SWIGINTERN int SWIG_Lua_class_tostring(lua_State *L)
{
/* there should be 1 param passed in
(1) userdata (not the metatable) */
swig_lua_userdata* userData;
assert(lua_isuserdata(L,1)); /* just in case */
userData = (swig_lua_userdata*)lua_touserdata(L,1); /* get the userdata address */
lua_pushfstring(L, "<userdata of type '%s' at %p>", userData->type->str, userData->ptr);
return 1;
}
/* to manually disown some userdata */
SWIGINTERN int SWIG_Lua_class_disown(lua_State *L)
{
/* there should be 1 params passed in
(1) userdata (not the meta table) */
swig_lua_userdata *usr;
assert(lua_isuserdata(L,-1)); /* just in case */
usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */
usr->own = 0; /* clear our ownership */
return 0;
}
/* lua callable function to compare userdata's value
the issue is that two userdata may point to the same thing
but to lua, they are different objects */
SWIGRUNTIME int SWIG_Lua_class_equal(lua_State *L)
{
int result;
swig_lua_userdata *usr1,*usr2;
if (!lua_isuserdata(L,1) || !lua_isuserdata(L,2)) /* just in case */
return 0; /* nil reply */
usr1=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */
usr2=(swig_lua_userdata*)lua_touserdata(L,2); /* get data */
/*result=(usr1->ptr==usr2->ptr && usr1->type==usr2->type); only works if type is the same*/
result=(usr1->ptr==usr2->ptr);
lua_pushboolean(L,result);
return 1;
}
/* populate table at the top of the stack with metamethods that ought to be inherited */
SWIGINTERN void SWIG_Lua_populate_inheritable_metamethods(lua_State *L)
{
SWIG_Lua_add_boolean(L, "__add", 1);
SWIG_Lua_add_boolean(L, "__sub", 1);
SWIG_Lua_add_boolean(L, "__mul", 1);
SWIG_Lua_add_boolean(L, "__div", 1);
SWIG_Lua_add_boolean(L, "__mod", 1);
SWIG_Lua_add_boolean(L, "__pow", 1);
SWIG_Lua_add_boolean(L, "__unm", 1);
SWIG_Lua_add_boolean(L, "__len", 1 );
SWIG_Lua_add_boolean(L, "__concat", 1 );
SWIG_Lua_add_boolean(L, "__eq", 1);
SWIG_Lua_add_boolean(L, "__lt", 1);
SWIG_Lua_add_boolean(L, "__le", 1);
SWIG_Lua_add_boolean(L, "__call", 1);
SWIG_Lua_add_boolean(L, "__tostring", 1);
SWIG_Lua_add_boolean(L, "__gc", 0);
}
/* creates the swig registry */
SWIGINTERN void SWIG_Lua_create_class_registry(lua_State *L)
{
/* create main SWIG registry table */
lua_pushstring(L,"SWIG");
lua_newtable(L);
/* populate it with some predefined data */
/* .library table. Placeholder */
lua_pushstring(L,".library");
lua_newtable(L);
{
/* list of metamethods that class inherits from its bases */
lua_pushstring(L,"inheritable_metamethods");
lua_newtable(L);
/* populate with list of metamethods */
SWIG_Lua_populate_inheritable_metamethods(L);
lua_rawset(L,-3);
}
lua_rawset(L,-3);
lua_rawset(L,LUA_REGISTRYINDEX);
}
/* gets the swig registry (or creates it) */
SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L)
{
/* add this all into the swig registry: */
lua_pushstring(L,"SWIG");
lua_rawget(L,LUA_REGISTRYINDEX); /* get the registry */
if (!lua_istable(L,-1)) /* not there */
{ /* must be first time, so add it */
lua_pop(L,1); /* remove the result */
SWIG_Lua_create_class_registry(L);
/* then get it */
lua_pushstring(L,"SWIG");
lua_rawget(L,LUA_REGISTRYINDEX);
}
}
SWIGINTERN void SWIG_Lua_get_inheritable_metamethods(lua_State *L)
{
SWIG_Lua_get_class_registry(L);
lua_pushstring(L, ".library");
lua_rawget(L,-2);
assert( !lua_isnil(L,-1) );
lua_pushstring(L, "inheritable_metamethods");
lua_rawget(L,-2);
/* Remove class registry and library table */
lua_remove(L,-2);
lua_remove(L,-2);
}
/* Helper function to get the classes metatable from the register */
SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname)
{
SWIG_Lua_get_class_registry(L); /* get the registry */
lua_pushstring(L,cname); /* get the name */
lua_rawget(L,-2); /* get it */
lua_remove(L,-2); /* tidy up (remove registry) */
}
/* Set up the base classes pointers.
Each class structure has a list of pointers to the base class structures.
This function fills them.
It cannot be done at compile time, as this will not work with hireachies
spread over more than one swig file.
Therefore it must be done at runtime, querying the SWIG type system.
*/
SWIGINTERN void SWIG_Lua_init_base_class(lua_State *L,swig_lua_class *clss)
{
int i=0;
swig_module_info *module=SWIG_GetModule(L);
for(i=0;clss->base_names[i];i++)
{
if (clss->bases[i]==0) /* not found yet */
{
/* lookup and cache the base class */
swig_type_info *info = SWIG_TypeQueryModule(module,module,clss->base_names[i]);
if (info) clss->bases[i] = (swig_lua_class *) info->clientdata;
}
}
}
#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
/* Merges two tables */
SWIGINTERN void SWIG_Lua_merge_tables_by_index(lua_State *L, int target, int source)
{
/* iterating */
lua_pushnil(L);
while (lua_next(L,source) != 0) {
/* -1 - value, -2 - index */
/* have to copy to assign */
lua_pushvalue(L,-2); /* copy of index */
lua_pushvalue(L,-2); /* copy of value */
lua_rawset(L, target);
lua_pop(L,1);
/* only key is left */
}
}
/* Merges two tables with given name. original - index of target metatable, base - index of source metatable */
SWIGINTERN void SWIG_Lua_merge_tables(lua_State *L, const char* name, int original, int base)
{
/* push original[name], then base[name] */
lua_pushstring(L,name);
lua_rawget(L,original);
int original_table = lua_gettop(L);
lua_pushstring(L,name);
lua_rawget(L,base);
int base_table = lua_gettop(L);
SWIG_Lua_merge_tables_by_index(L, original_table, base_table);
/* clearing stack */
lua_pop(L,2);
}
/* Function takes all symbols from base and adds it to derived class. It's just a helper. */
SWIGINTERN void SWIG_Lua_class_squash_base(lua_State *L, swig_lua_class *base_cls)
{
/* There is one parameter - original, i.e. 'derived' class metatable */
assert(lua_istable(L,-1));
int original = lua_gettop(L);
SWIG_Lua_get_class_metatable(L,base_cls->fqname);
int base = lua_gettop(L);
SWIG_Lua_merge_tables(L, ".fn", original, base );
SWIG_Lua_merge_tables(L, ".set", original, base );
SWIG_Lua_merge_tables(L, ".get", original, base );
lua_pop(L,1);
}
/* Function squashes all symbols from 'clss' bases into itself */
SWIGINTERN void SWIG_Lua_class_squash_bases(lua_State *L, swig_lua_class *clss)
{
int i;
SWIG_Lua_get_class_metatable(L,clss->fqname);
for(i=0;clss->base_names[i];i++)
{
if (clss->bases[i]==0) /* Somehow it's not found. Skip it */
continue;
/* Thing is: all bases are already registered. Thus they have already executed
* this function. So we just need to squash them into us, because their bases
* are already squashed into them. No need for recursion here!
*/
SWIG_Lua_class_squash_base(L, clss->bases[i]);
}
lua_pop(L,1); /*tidy stack*/
}
#endif
#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */
/* helper add a variable to a registered class */
SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn)
{
assert(lua_istable(L,-1)); /* just in case */
SWIG_Lua_get_table(L,".get"); /* find the .get table */
assert(lua_istable(L,-1)); /* just in case */
SWIG_Lua_add_function(L,name,getFn);
lua_pop(L,1); /* tidy stack (remove table) */
if (setFn)
{
SWIG_Lua_get_table(L,".set"); /* find the .set table */
assert(lua_istable(L,-1)); /* just in case */
SWIG_Lua_add_function(L,name,setFn);
lua_pop(L,1); /* tidy stack (remove table) */
}
}
/* helper to recursively add class static details (static attributes, operations and constants) */
SWIGINTERN void SWIG_Lua_add_class_static_details(lua_State *L, swig_lua_class *clss)
{
int i = 0;
/* The class namespace table must be on the top of the stack */
assert(lua_istable(L,-1));
/* call all the base classes first: we can then override these later: */
for(i=0;clss->bases[i];i++)
{
SWIG_Lua_add_class_static_details(L,clss->bases[i]);
}
SWIG_Lua_add_namespace_details(L, clss->cls_static);
}
SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss); /* forward declaration */
/* helper to recursively add class details (attributes & operations) */
SWIGINTERN void SWIG_Lua_add_class_instance_details(lua_State *L, swig_lua_class *clss)
{
int i;
size_t bases_count = 0;
/* Add bases to .bases table */
SWIG_Lua_get_table(L,".bases");
assert(lua_istable(L,-1)); /* just in case */
for(i=0;clss->bases[i];i++)
{
SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname);
/* Base class must be already registered */
assert(lua_istable(L,-1));
lua_rawseti(L,-2,i+1); /* In lua indexing starts from 1 */
bases_count++;
}
assert(lua_rawlen(L,-1) == bases_count);
lua_pop(L,1); /* remove .bases table */
/* add attributes */
for(i=0;clss->attributes[i].name;i++){
SWIG_Lua_add_variable(L,clss->attributes[i].name,clss->attributes[i].getmethod,clss->attributes[i].setmethod);
}
/* add methods to the metatable */
SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
assert(lua_istable(L,-1)); /* just in case */
for(i=0;clss->methods[i].name;i++){
SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].func);
}
lua_pop(L,1); /* tidy stack (remove table) */
/* add operator overloads
This adds methods from metatable array to metatable. Can mess up garbage
collectind if someone defines __gc method
*/
if(clss->metatable) {
for(i=0;clss->metatable[i].name;i++) {
SWIG_Lua_add_function(L,clss->metatable[i].name,clss->metatable[i].func);
}
}
#if !defined(SWIG_LUA_SQUASH_BASES)
/* Adding metamethods that are defined in base classes. If bases were squashed
* then it is obviously unnecessary
*/
SWIG_Lua_add_class_user_metamethods(L, clss);
#endif
}
/* Helpers to add user defined class metamedhods - __add, __sub etc. The helpers are needed
for the following issue: Lua runtime checks for metamethod existence with rawget function
ignoring our SWIG-provided __index and __newindex functions. Thus our inheritance-aware method
search algorithm doesn't work in such case. (Not to say that Lua runtime queries metamethod directly
in metatable and not in object).
Current solution is this: if somewhere in hierarchy metamethod __x is defined, then all descendants
are automatically given a special proxy __x that calls the real __x method.
Obvious idea - to copy __x instead of creating __x-proxy is wrong because if someone changes __x in runtime,
those changes must be reflected in all descendants.
*/
SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L); /*forward declaration*/
/* The real function that resolves a metamethod.
* Function searches given class and all it's bases(recursively) for first instance of something that is
* not equal to SWIG_Lua_resolve_metatmethod. (Almost always this 'something' is actual metamethod implementation
* and it is a SWIG-generated C function.). It returns value on the top of the L and there is no garbage below the
* answer.
* Returns 1 if found, 0 otherwise.
* clss is class which metatable we will search for method
* metamethod_name_idx is index in L where metamethod name (as string) lies
* skip_check allows to skip searching metamethod in givel clss and immideatelly go to searching in bases. skip_check
* is not caried to subsequent recursive calls - false is always passed. It is set to true only at first call from
* SWIG_Lua_resolve_metamethod
* */
SWIGINTERN int SWIG_Lua_do_resolve_metamethod(lua_State *L, const swig_lua_class *clss, int metamethod_name_idx,
int skip_check)
{
/* This function is called recursively */
int result = 0;
int i = 0;
if (!skip_check) {
SWIG_Lua_get_class_metatable(L, clss->fqname);
lua_pushvalue(L, metamethod_name_idx);
lua_rawget(L,-2);
/* If this is cfunction and it is equal to SWIG_Lua_resolve_metamethod then
* this isn't the function we are looking for :)
* lua_tocfunction will return NULL if not cfunction
*/
if (!lua_isnil(L,-1) && lua_tocfunction(L,-1) != SWIG_Lua_resolve_metamethod ) {
lua_remove(L,-2); /* removing class metatable */
return 1;
}
lua_pop(L,2); /* remove class metatable and query result */
}
/* Forwarding calls to bases */
for(i=0;clss->bases[i];i++)
{
result = SWIG_Lua_do_resolve_metamethod(L, clss->bases[i], metamethod_name_idx, 0);
if (result)
break;
}
return result;
}
/* The proxy function for metamethod. All parameters are passed as cclosure. Searches for actual method
* and calls it */
SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L)
{
int numargs;
int metamethod_name_idx;
const swig_lua_class* clss;
int result;
lua_checkstack(L,5);
numargs = lua_gettop(L); /* number of arguments to pass to actual metamethod */
/* Get upvalues from closure */
lua_pushvalue(L, lua_upvalueindex(1)); /*Get function name*/
metamethod_name_idx = lua_gettop(L);
lua_pushvalue(L, lua_upvalueindex(2));
clss = (const swig_lua_class*)(lua_touserdata(L,-1));
lua_pop(L,1); /* remove lightuserdata with clss from stack */
/* Actual work */
result = SWIG_Lua_do_resolve_metamethod(L, clss, metamethod_name_idx, 1);
if (!result) {
SWIG_Lua_pushferrstring(L,"The metamethod proxy is set, but it failed to find actual metamethod. Memory corruption is most likely explanation.");
lua_error(L);
return 0;
}
lua_remove(L,-2); /* remove metamethod key */
lua_insert(L,1); /* move function to correct position */
lua_call(L, numargs, LUA_MULTRET);
return lua_gettop(L); /* return all results */
}
/* If given metamethod must be present in given class, then creates appropriate proxy
* Returns 1 if successfully added, 0 if not added because no base class has it, -1
* if method is defined in the class metatable itself
*/
SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class *clss, const int metatable_index)
{
int key_index;
int success = 0;
int i = 0;
/* metamethod name - on the top of the stack */
assert(lua_isstring(L,-1));
key_index = lua_gettop(L);
/* Check whether method is already defined in metatable */
lua_pushvalue(L,key_index); /* copy of the key */
lua_gettable(L,metatable_index);
if( !lua_isnil(L,-1) ) {
lua_pop(L,1);
return -1;
}
lua_pop(L,1);
/* Iterating over immediate bases */
for(i=0;clss->bases[i];i++)
{
const swig_lua_class *base = clss->bases[i];
SWIG_Lua_get_class_metatable(L, base->fqname);
lua_pushvalue(L, key_index);
lua_rawget(L, -2);
if( !lua_isnil(L,-1) ) {
lua_pushvalue(L, key_index);
/* Add proxy function */
lua_pushvalue(L, key_index); /* first closure value is function name */
lua_pushlightuserdata(L, clss); /* second closure value is swig_lua_class structure */
lua_pushcclosure(L, SWIG_Lua_resolve_metamethod, 2);
lua_rawset(L, metatable_index);
success = 1;
}
lua_pop(L,1); /* remove function or nil */
lua_pop(L,1); /* remove base class metatable */
if( success )
break;
}
return success;
}
SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss)
{
int metatable_index;
int metamethods_info_index;
int tostring_undefined;
int eq_undefined = 0;
SWIG_Lua_get_class_metatable(L, clss->fqname);
metatable_index = lua_gettop(L);
SWIG_Lua_get_inheritable_metamethods(L);
assert(lua_istable(L,-1));
metamethods_info_index = lua_gettop(L);
lua_pushnil(L); /* first key */
while(lua_next(L, metamethods_info_index) != 0 ) {
/* key at index -2, value at index -1 */
const int is_inheritable = lua_toboolean(L,-2);
lua_pop(L,1); /* remove value - we don't need it anymore */
if(is_inheritable) { /* if metamethod is inheritable */
SWIG_Lua_add_class_user_metamethod(L,clss,metatable_index);
}
}
lua_pop(L,1); /* remove inheritable metatmethods table */
/* Special handling for __tostring method */
lua_pushstring(L, "__tostring");
lua_pushvalue(L,-1);
lua_rawget(L,metatable_index);
tostring_undefined = lua_isnil(L,-1);
lua_pop(L,1);
if( tostring_undefined ) {
lua_pushcfunction(L, SWIG_Lua_class_tostring);
lua_rawset(L, metatable_index);
} else {
lua_pop(L,1); /* remove copy of the key */
}
/* Special handling for __eq method */
lua_pushstring(L, "__eq");
lua_pushvalue(L,-1);
lua_rawget(L,metatable_index);
eq_undefined = lua_isnil(L,-1);
lua_pop(L,1);
if( eq_undefined ) {
lua_pushcfunction(L, SWIG_Lua_class_equal);
lua_rawset(L, metatable_index);
} else {
lua_pop(L,1); /* remove copy of the key */
}
/* Warning: __index and __newindex are SWIG-defined. For user-defined operator[]
* a __getitem/__setitem method should be defined
*/
lua_pop(L,1); /* pop class metatable */
}
/* Register class static methods,attributes etc as well as constructor proxy */
SWIGINTERN void SWIG_Lua_class_register_static(lua_State *L, swig_lua_class *clss)
{
const int SWIGUNUSED begin = lua_gettop(L);
lua_checkstack(L,5); /* just in case */
assert(lua_istable(L,-1)); /* just in case */
assert(strcmp(clss->name, clss->cls_static->name) == 0); /* in class those 2 must be equal */
SWIG_Lua_namespace_register(L,clss->cls_static, 1);
assert(lua_istable(L,-1)); /* just in case */
/* add its constructor to module with the name of the class
so you can do MyClass(...) as well as new_MyClass(...)
BUT only if a constructor is defined
(this overcomes the problem of pure virtual classes without constructors)*/
if (clss->constructor)
{
lua_getmetatable(L,-1);
assert(lua_istable(L,-1)); /* just in case */
SWIG_Lua_add_function(L,"__call", clss->constructor);
lua_pop(L,1);
}
assert(lua_istable(L,-1)); /* just in case */
SWIG_Lua_add_class_static_details(L, clss);
/* clear stack */
lua_pop(L,1);
assert( lua_gettop(L) == begin );
}
/* Performs the instance (non-static) class registration process. Metatable for class is created
* and added to the class registry.
*/
SWIGINTERN void SWIG_Lua_class_register_instance(lua_State *L,swig_lua_class *clss)
{
const int SWIGUNUSED begin = lua_gettop(L);
int i;
/* if name already there (class is already registered) then do nothing */
SWIG_Lua_get_class_registry(L); /* get the registry */
lua_pushstring(L,clss->fqname); /* get the name */
lua_rawget(L,-2);
if(!lua_isnil(L,-1)) {
lua_pop(L,2);
assert(lua_gettop(L)==begin);
return;
}
lua_pop(L,2); /* tidy stack */
/* Recursively initialize all bases */
for(i=0;clss->bases[i];i++)
{
SWIG_Lua_class_register_instance(L,clss->bases[i]);
}
/* Again, get registry and push name */
SWIG_Lua_get_class_registry(L); /* get the registry */
lua_pushstring(L,clss->fqname); /* get the name */
lua_newtable(L); /* create the metatable */
#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
/* If squashing is requested, then merges all bases metatable into this one.
* It would get us all special methods: __getitem, __add etc.
* This would set .fn, .type, and other .xxx incorrectly, but we will overwrite it right away
*/
{
int new_metatable_index = lua_absindex(L,-1);
for(i=0;clss->bases[i];i++)
{
int base_metatable;
SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname);
base_metatable = lua_absindex(L,-1);
SWIG_Lua_merge_tables_by_index(L,new_metatable_index, base_metatable);
lua_pop(L,1);
}
}
/* And now we will overwrite all incorrectly set data */
#endif
/* add string of class name called ".type" */
lua_pushstring(L,".type");
lua_pushstring(L,clss->fqname);
lua_rawset(L,-3);
/* add a table called bases */
lua_pushstring(L,".bases");
lua_newtable(L);
lua_rawset(L,-3);
/* add a table called ".get" */
lua_pushstring(L,".get");
lua_newtable(L);
lua_rawset(L,-3);
/* add a table called ".set" */
lua_pushstring(L,".set");
lua_newtable(L);
lua_rawset(L,-3);
/* add a table called ".fn" */
lua_pushstring(L,".fn");
lua_newtable(L);
/* add manual disown method */
SWIG_Lua_add_function(L,"__disown",SWIG_Lua_class_disown);
lua_rawset(L,-3);
/* add accessor fns for using the .get,.set&.fn */
SWIG_Lua_add_function(L,"__index",SWIG_Lua_class_get);
SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_class_set);
SWIG_Lua_add_function(L,"__gc",SWIG_Lua_class_destruct);
/* add it */
lua_rawset(L,-3); /* metatable into registry */
lua_pop(L,1); /* tidy stack (remove registry) */
assert(lua_gettop(L) == begin);
#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
/* Now merge all symbols from .fn, .set, .get etc from bases to our tables */
SWIG_Lua_class_squash_bases(L,clss);
#endif
SWIG_Lua_get_class_metatable(L,clss->fqname);
SWIG_Lua_add_class_instance_details(L,clss); /* recursive adding of details (atts & ops) */
lua_pop(L,1); /* tidy stack (remove class metatable) */
assert( lua_gettop(L) == begin );
}
SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss)
{
int SWIGUNUSED begin;
assert(lua_istable(L,-1)); /* This is a table (module or namespace) where classes will be added */
SWIG_Lua_class_register_instance(L,clss);
SWIG_Lua_class_register_static(L,clss);
/* Add links from static part to instance part and vice versa */
/* [SWIG registry] [Module]
* "MyClass" ----> [MyClass metatable] <===== "MyClass" -+> [static part]
* ".get" ----> ... | | getmetatable()----|
* ".set" ----> ... | | |
* ".static" --------------)----------------/ [static part metatable]
* | ".get" --> ...
* | ".set" --> ....
* |=============================== ".instance"
*/
begin = lua_gettop(L);
lua_pushstring(L,clss->cls_static->name);
lua_rawget(L,-2); /* get class static table */
assert(lua_istable(L,-1));
lua_getmetatable(L,-1);
assert(lua_istable(L,-1)); /* get class static metatable */
lua_pushstring(L,".instance"); /* prepare key */
SWIG_Lua_get_class_metatable(L,clss->fqname); /* get class metatable */
assert(lua_istable(L,-1));
lua_pushstring(L,".static"); /* prepare key */
lua_pushvalue(L, -4); /* push static class TABLE */
assert(lua_istable(L,-1));
lua_rawset(L,-3); /* assign static class table(!NOT metatable) as ".static" member of class metatable */
lua_rawset(L,-3); /* assign class metatable as ".instance" member of class static METATABLE */
lua_pop(L,2);
assert(lua_gettop(L) == begin);
}
#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */
#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
SWIGINTERN void SWIG_Lua_elua_class_register_instance(lua_State *L, swig_lua_class *clss)
{
const int SWIGUNUSED begin = lua_gettop(L);
int i;
/* if name already there (class is already registered) then do nothing */
SWIG_Lua_get_class_registry(L); /* get the registry */
lua_pushstring(L,clss->fqname); /* get the name */
lua_rawget(L,-2);
if(!lua_isnil(L,-1)) {
lua_pop(L,2);
assert(lua_gettop(L)==begin);
return;
}
lua_pop(L,2); /* tidy stack */
/* Recursively initialize all bases */
for(i=0;clss->bases[i];i++)
{
SWIG_Lua_elua_class_register_instance(L,clss->bases[i]);
}
/* Again, get registry and push name */
SWIG_Lua_get_class_registry(L); /* get the registry */
lua_pushstring(L,clss->fqname); /* get the name */
assert(clss->metatable);
lua_pushrotable(L, (void*)(clss->metatable)); /* create the metatable */
lua_rawset(L,-3);
lua_pop(L,1);
assert(lua_gettop(L) == begin);
}
#endif /* elua && eluac */
/* -----------------------------------------------------------------------------
* Class/structure conversion fns
* ----------------------------------------------------------------------------- */
/* helper to add metatable to new lua object */
SWIGINTERN void SWIG_Lua_AddMetatable(lua_State *L,swig_type_info *type)
{
if (type->clientdata) /* there is clientdata: so add the metatable */
{
SWIG_Lua_get_class_metatable(L,((swig_lua_class*)(type->clientdata))->fqname);
if (lua_istable(L,-1))
{
lua_setmetatable(L,-2);
}
else
{
lua_pop(L,1);
}
}
}
/* pushes a new object into the lua stack */
SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own)
{
swig_lua_userdata *usr;
if (!ptr){
lua_pushnil(L);
return;
}
usr=(swig_lua_userdata*)lua_newuserdata(L,sizeof(swig_lua_userdata)); /* get data */
usr->ptr=ptr; /* set the ptr */
usr->type=type;
usr->own=own;
#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
SWIG_Lua_AddMetatable(L,type); /* add metatable */
#endif
}
/* takes a object from the lua stack & converts it into an object of the correct type
(if possible) */
SWIGRUNTIME int SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type_info *type,int flags)
{
swig_lua_userdata *usr;
swig_cast_info *cast;
/* special case: lua nil => NULL pointer */
if (lua_isnil(L,index))
{
*ptr=0;
return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
}
if (lua_islightuserdata(L,index))
{
*ptr=lua_touserdata(L,index);
return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
}
usr=(swig_lua_userdata*)lua_touserdata(L,index); /* get data */
if (usr)
{
if (flags & SWIG_POINTER_DISOWN) /* must disown the object */
{
usr->own=0;
}
if (!type) /* special cast void*, no casting fn */
{
*ptr=usr->ptr;
return SWIG_OK; /* ok */
}
cast=SWIG_TypeCheckStruct(usr->type,type); /* performs normal type checking */
if (cast)
{
int newmemory = 0;
*ptr=SWIG_TypeCast(cast,usr->ptr,&newmemory);
assert(!newmemory); /* newmemory handling not yet implemented */
return SWIG_OK; /* ok */
}
}
return SWIG_ERROR; /* error */
}
SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State *L,int index,swig_type_info *type,int flags,
int argnum,const char *func_name){
void *result;
if (!SWIG_IsOK(SWIG_ConvertPtr(L,index,&result,type,flags))){
luaL_error (L,"Error in %s, expected a %s at argument number %d\n",
func_name,(type && type->str)?type->str:"void*",argnum);
}
return result;
}
/* pushes a packed userdata. user for member fn pointers only */
SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type)
{
swig_lua_rawdata *raw;
assert(ptr); /* not acceptable to pass in a NULL value */
raw=(swig_lua_rawdata*)lua_newuserdata(L,sizeof(swig_lua_rawdata)-1+size); /* alloc data */
raw->type=type;
raw->own=0;
memcpy(raw->data,ptr,size); /* copy the data */
SWIG_Lua_AddMetatable(L,type); /* add metatable */
}
/* converts a packed userdata. user for member fn pointers only */
SWIGRUNTIME int SWIG_Lua_ConvertPacked(lua_State *L,int index,void *ptr,size_t size,swig_type_info *type)
{
swig_lua_rawdata *raw;
raw=(swig_lua_rawdata*)lua_touserdata(L,index); /* get data */
if (!raw) return SWIG_ERROR; /* error */
if (type==0 || type==raw->type) /* void* or identical type */
{
memcpy(ptr,raw->data,size); /* copy it */
return SWIG_OK; /* ok */
}
return SWIG_ERROR; /* error */
}
/* a function to get the typestring of a piece of data */
SWIGRUNTIME const char *SWIG_Lua_typename(lua_State *L, int tp)
{
swig_lua_userdata *usr;
if (lua_isuserdata(L,tp))
{
usr=(swig_lua_userdata*)lua_touserdata(L,tp); /* get data */
if (usr && usr->type && usr->type->str)
return usr->type->str;
return "userdata (unknown type)";
}
return lua_typename(L,lua_type(L,tp));
}
/* lua callable function to get the userdata's type */
SWIGRUNTIME int SWIG_Lua_type(lua_State *L)
{
lua_pushstring(L,SWIG_Lua_typename(L,1));
return 1;
}
/* -----------------------------------------------------------------------------
* global variable support code: class/struct typemap functions
* ----------------------------------------------------------------------------- */
#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
/* Install Constants */
SWIGINTERN void
SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]) {
int i;
for (i = 0; constants[i].type; i++) {
switch(constants[i].type) {
case SWIG_LUA_INT:
lua_pushstring(L,constants[i].name);
lua_pushinteger(L,(lua_Integer)constants[i].lvalue);
lua_rawset(L,-3);
break;
case SWIG_LUA_FLOAT:
lua_pushstring(L,constants[i].name);
lua_pushnumber(L,(lua_Number)constants[i].dvalue);
lua_rawset(L,-3);
break;
case SWIG_LUA_CHAR:
lua_pushstring(L,constants[i].name);
{
char c = (char)constants[i].lvalue;
lua_pushlstring(L,&c,1);
}
lua_rawset(L,-3);
break;
case SWIG_LUA_STRING:
lua_pushstring(L,constants[i].name);
lua_pushstring(L,(char *) constants[i].pvalue);
lua_rawset(L,-3);
break;
case SWIG_LUA_POINTER:
lua_pushstring(L,constants[i].name);
SWIG_NewPointerObj(L,constants[i].pvalue, *(constants[i]).ptype,0);
lua_rawset(L,-3);
break;
case SWIG_LUA_BINARY:
lua_pushstring(L,constants[i].name);
SWIG_NewMemberObj(L,constants[i].pvalue,constants[i].lvalue,*(constants[i]).ptype);
lua_rawset(L,-3);
break;
default:
break;
}
}
}
#endif
/* -----------------------------------------------------------------------------
* executing lua code from within the wrapper
* ----------------------------------------------------------------------------- */
#ifndef SWIG_DOSTRING_FAIL /* Allows redefining of error function */
#define SWIG_DOSTRING_FAIL(S) fprintf(stderr,"%s\n",S)
#endif
/* Executes a C string in Lua which is a really simple way of calling lua from C
Unfortunately lua keeps changing its APIs, so we need a conditional compile
In lua 5.0.X it's lua_dostring()
In lua 5.1.X it's luaL_dostring()
*/
SWIGINTERN int
SWIG_Lua_dostring(lua_State *L, const char *str) {
int ok,top;
if (str==0 || str[0]==0) return 0; /* nothing to do */
top=lua_gettop(L); /* save stack */
#if (defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM>=501))
ok=luaL_dostring(L,str); /* looks like this is lua 5.1.X or later, good */
#else
ok=lua_dostring(L,str); /* might be lua 5.0.x, using lua_dostring */
#endif
if (ok!=0) {
SWIG_DOSTRING_FAIL(lua_tostring(L,-1));
}
lua_settop(L,top); /* restore the stack */
return ok;
}
#ifdef __cplusplus
}
#endif
/* ------------------------------ end luarun.swg ------------------------------ */
/* -------- TYPES TABLE (BEGIN) -------- */
#define SWIGTYPE_p_bool swig_types[0]
#define SWIGTYPE_p_double swig_types[1]
#define SWIGTYPE_p_f_p_q_const__char_p_void__void swig_types[2]
#define SWIGTYPE_p_f_p_void__p_void swig_types[3]
#define SWIGTYPE_p_f_p_void_p_q_const__void_size_t__void swig_types[4]
#define SWIGTYPE_p_int swig_types[5]
#define SWIGTYPE_p_lldb__ConnectionStatus swig_types[6]
#define SWIGTYPE_p_lldb__SBAddress swig_types[7]
#define SWIGTYPE_p_lldb__SBAttachInfo swig_types[8]
#define SWIGTYPE_p_lldb__SBBlock swig_types[9]
#define SWIGTYPE_p_lldb__SBBreakpoint swig_types[10]
#define SWIGTYPE_p_lldb__SBBreakpointList swig_types[11]
#define SWIGTYPE_p_lldb__SBBreakpointLocation swig_types[12]
#define SWIGTYPE_p_lldb__SBBreakpointName swig_types[13]
#define SWIGTYPE_p_lldb__SBBroadcaster swig_types[14]
#define SWIGTYPE_p_lldb__SBCommandInterpreter swig_types[15]
#define SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions swig_types[16]
#define SWIGTYPE_p_lldb__SBCommandReturnObject swig_types[17]
#define SWIGTYPE_p_lldb__SBCommunication swig_types[18]
#define SWIGTYPE_p_lldb__SBCompileUnit swig_types[19]
#define SWIGTYPE_p_lldb__SBData swig_types[20]
#define SWIGTYPE_p_lldb__SBDebugger swig_types[21]
#define SWIGTYPE_p_lldb__SBDeclaration swig_types[22]
#define SWIGTYPE_p_lldb__SBEnvironment swig_types[23]
#define SWIGTYPE_p_lldb__SBError swig_types[24]
#define SWIGTYPE_p_lldb__SBEvent swig_types[25]
#define SWIGTYPE_p_lldb__SBExecutionContext swig_types[26]
#define SWIGTYPE_p_lldb__SBExpressionOptions swig_types[27]
#define SWIGTYPE_p_lldb__SBFile swig_types[28]
#define SWIGTYPE_p_lldb__SBFileSpec swig_types[29]
#define SWIGTYPE_p_lldb__SBFileSpecList swig_types[30]
#define SWIGTYPE_p_lldb__SBFrame swig_types[31]
#define SWIGTYPE_p_lldb__SBFunction swig_types[32]
#define SWIGTYPE_p_lldb__SBHostOS swig_types[33]
#define SWIGTYPE_p_lldb__SBInstruction swig_types[34]
#define SWIGTYPE_p_lldb__SBInstructionList swig_types[35]
#define SWIGTYPE_p_lldb__SBLanguageRuntime swig_types[36]
#define SWIGTYPE_p_lldb__SBLaunchInfo swig_types[37]
#define SWIGTYPE_p_lldb__SBLineEntry swig_types[38]
#define SWIGTYPE_p_lldb__SBListener swig_types[39]
#define SWIGTYPE_p_lldb__SBMemoryRegionInfo swig_types[40]
#define SWIGTYPE_p_lldb__SBMemoryRegionInfoList swig_types[41]
#define SWIGTYPE_p_lldb__SBModule swig_types[42]
#define SWIGTYPE_p_lldb__SBModuleSpec swig_types[43]
#define SWIGTYPE_p_lldb__SBModuleSpecList swig_types[44]
#define SWIGTYPE_p_lldb__SBPlatform swig_types[45]
#define SWIGTYPE_p_lldb__SBPlatformConnectOptions swig_types[46]
#define SWIGTYPE_p_lldb__SBPlatformShellCommand swig_types[47]
#define SWIGTYPE_p_lldb__SBProcess swig_types[48]
#define SWIGTYPE_p_lldb__SBProcessInfo swig_types[49]
#define SWIGTYPE_p_lldb__SBQueue swig_types[50]
#define SWIGTYPE_p_lldb__SBQueueItem swig_types[51]
#define SWIGTYPE_p_lldb__SBReproducer swig_types[52]
#define SWIGTYPE_p_lldb__SBSection swig_types[53]
#define SWIGTYPE_p_lldb__SBSourceManager swig_types[54]
#define SWIGTYPE_p_lldb__SBStream swig_types[55]
#define SWIGTYPE_p_lldb__SBStringList swig_types[56]
#define SWIGTYPE_p_lldb__SBStructuredData swig_types[57]
#define SWIGTYPE_p_lldb__SBSymbol swig_types[58]
#define SWIGTYPE_p_lldb__SBSymbolContext swig_types[59]
#define SWIGTYPE_p_lldb__SBSymbolContextList swig_types[60]
#define SWIGTYPE_p_lldb__SBTarget swig_types[61]
#define SWIGTYPE_p_lldb__SBThread swig_types[62]
#define SWIGTYPE_p_lldb__SBThreadCollection swig_types[63]
#define SWIGTYPE_p_lldb__SBThreadPlan swig_types[64]
#define SWIGTYPE_p_lldb__SBTrace swig_types[65]
#define SWIGTYPE_p_lldb__SBType swig_types[66]
#define SWIGTYPE_p_lldb__SBTypeCategory swig_types[67]
#define SWIGTYPE_p_lldb__SBTypeEnumMember swig_types[68]
#define SWIGTYPE_p_lldb__SBTypeEnumMemberList swig_types[69]
#define SWIGTYPE_p_lldb__SBTypeFilter swig_types[70]
#define SWIGTYPE_p_lldb__SBTypeFormat swig_types[71]
#define SWIGTYPE_p_lldb__SBTypeList swig_types[72]
#define SWIGTYPE_p_lldb__SBTypeMember swig_types[73]
#define SWIGTYPE_p_lldb__SBTypeMemberFunction swig_types[74]
#define SWIGTYPE_p_lldb__SBTypeNameSpecifier swig_types[75]
#define SWIGTYPE_p_lldb__SBTypeSummary swig_types[76]
#define SWIGTYPE_p_lldb__SBTypeSummaryOptions swig_types[77]
#define SWIGTYPE_p_lldb__SBTypeSynthetic swig_types[78]
#define SWIGTYPE_p_lldb__SBUnixSignals swig_types[79]
#define SWIGTYPE_p_lldb__SBValue swig_types[80]
#define SWIGTYPE_p_lldb__SBValueList swig_types[81]
#define SWIGTYPE_p_lldb__SBVariablesOptions swig_types[82]
#define SWIGTYPE_p_lldb__SBWatchpoint swig_types[83]
#define SWIGTYPE_p_long_double swig_types[84]
#define SWIGTYPE_p_long_long swig_types[85]
#define SWIGTYPE_p_p_void swig_types[86]
#define SWIGTYPE_p_pthread_rwlock_t swig_types[87]
#define SWIGTYPE_p_pthread_t swig_types[88]
#define SWIGTYPE_p_short swig_types[89]
#define SWIGTYPE_p_signed_char swig_types[90]
#define SWIGTYPE_p_size_t swig_types[91]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ABI_t swig_types[92]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Baton_t swig_types[93]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Block_t swig_types[94]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointLocation_t swig_types[95]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointPrecondition_t swig_types[96]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointResolver_t swig_types[97]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointSite_t swig_types[98]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Breakpoint_t swig_types[99]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BroadcasterManager_t swig_types[100]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Broadcaster_t swig_types[101]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__CommandObject_t swig_types[102]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__CompileUnit_t swig_types[103]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Connection_t swig_types[104]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__DataBuffer_t swig_types[105]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__DataExtractor_t swig_types[106]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Debugger_t swig_types[107]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Disassembler_t swig_types[108]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__EventDataStructuredData_t swig_types[109]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__EventData_t swig_types[110]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Event_t swig_types[111]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ExecutionContextRef_t swig_types[112]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ExpressionVariable_t swig_types[113]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__File_t swig_types[114]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__FuncUnwinders_t swig_types[115]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Function_t swig_types[116]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__IOHandler_t swig_types[117]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__IOObject_t swig_types[118]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__IRExecutionUnit_t swig_types[119]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__InlineFunctionInfo_t swig_types[120]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Instruction_t swig_types[121]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__InstrumentationRuntime_t swig_types[122]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__JITLoader_t swig_types[123]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__LanguageRuntime_t swig_types[124]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Listener_t swig_types[125]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__MemoryHistory_t swig_types[126]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t swig_types[127]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Module_t swig_types[128]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t swig_types[129]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ObjectFile_t swig_types[130]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueProperties_t swig_types[131]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValue_t swig_types[132]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Platform_t swig_types[133]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t swig_types[134]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Process_t swig_types[135]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__QueueItem_t swig_types[136]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Queue_t swig_types[137]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__REPL_t swig_types[138]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RecognizedStackFrame_t swig_types[139]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t swig_types[140]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegisterContext_t swig_types[141]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegularExpression_t swig_types[142]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptInterpreter_t swig_types[143]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t swig_types[144]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t swig_types[145]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedThreadInterface_t swig_types[146]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SearchFilter_t swig_types[147]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SectionLoadList_t swig_types[148]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Section_t swig_types[149]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrameList_t swig_types[150]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrameRecognizer_t swig_types[151]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrame_t swig_types[152]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StopInfo_t swig_types[153]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StreamFile_t swig_types[154]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Stream_t swig_types[155]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StringSummaryFormat_t swig_types[156]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t swig_types[157]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t swig_types[158]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SymbolFileType_t swig_types[159]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t swig_types[160]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SyntheticChildren_t swig_types[161]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Target_t swig_types[162]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadCollection_t swig_types[163]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t swig_types[164]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPlan_t swig_types[165]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPostMortemTrace_t swig_types[166]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Thread_t swig_types[167]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Trace_t swig_types[168]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t swig_types[169]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t swig_types[170]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeFilterImpl_t swig_types[171]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeFormatImpl_t swig_types[172]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeImpl_t swig_types[173]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t swig_types[174]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t swig_types[175]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t swig_types[176]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t swig_types[177]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSystem_t swig_types[178]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Type_t swig_types[179]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnixSignals_t swig_types[180]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnwindAssembly_t swig_types[181]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnwindPlan_t swig_types[182]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UserExpression_t swig_types[183]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ValueObjectList_t swig_types[184]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ValueObject_t swig_types[185]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Value_t swig_types[186]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__VariableList_t swig_types[187]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Variable_t swig_types[188]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Watchpoint_t swig_types[189]
#define SWIGTYPE_p_std__string swig_types[190]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t swig_types[191]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__DynamicLoader_t swig_types[192]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__File_t swig_types[193]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__JITLoaderList_t swig_types[194]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t swig_types[195]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__OperatingSystem_t swig_types[196]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__ScriptedProcessInterface_t swig_types[197]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SectionList_t swig_types[198]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SourceManager_t swig_types[199]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__StackFrameRecognizerManager_t swig_types[200]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__StructuredDataImpl_t swig_types[201]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SymbolVendor_t swig_types[202]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SystemRuntime_t swig_types[203]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__TraceCursor_t swig_types[204]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__TraceExporter_t swig_types[205]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__BreakpointLocation_t swig_types[206]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Breakpoint_t swig_types[207]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__BroadcasterManager_t swig_types[208]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Debugger_t swig_types[209]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Listener_t swig_types[210]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Module_t swig_types[211]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t swig_types[212]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__OptionValue_t swig_types[213]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Process_t swig_types[214]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Queue_t swig_types[215]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Section_t swig_types[216]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__StackFrame_t swig_types[217]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t swig_types[218]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Target_t swig_types[219]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__ThreadPlan_t swig_types[220]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Thread_t swig_types[221]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Type_t swig_types[222]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__UnixSignals_t swig_types[223]
#define SWIGTYPE_p_unsigned_char swig_types[224]
#define SWIGTYPE_p_unsigned_int swig_types[225]
#define SWIGTYPE_p_unsigned_long_long swig_types[226]
#define SWIGTYPE_p_unsigned_short swig_types[227]
#define SWIGTYPE_p_void swig_types[228]
static swig_type_info *swig_types[230];
static swig_module_info swig_module = {swig_types, 229, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
/* -------- TYPES TABLE (END) -------- */
#define SWIG_name "lldb"
#define SWIG_init luaopen_lldb
#define SWIG_init_user luaopen_lldb_user
#define SWIG_LUACODE luaopen_lldb_luacode
namespace swig {
typedef struct{} LANGUAGE_OBJ;
}
#include <string>
SWIGINTERN int SWIG_lua_isnilstring(lua_State *L, int idx) {
int ret = lua_isstring(L, idx);
if (!ret)
ret = lua_isnil(L, idx);
return ret;
}
#ifdef __cplusplus /* generic alloc/dealloc fns*/
#define SWIG_ALLOC_ARRAY(TYPE,LEN) new TYPE[LEN]
#define SWIG_FREE_ARRAY(PTR) delete[] PTR
#else
#define SWIG_ALLOC_ARRAY(TYPE,LEN) (TYPE *)malloc(LEN*sizeof(TYPE))
#define SWIG_FREE_ARRAY(PTR) free(PTR)
#endif
/* counting the size of arrays:*/
SWIGINTERN int SWIG_itable_size(lua_State* L, int index)
{
int n=0;
while(1){
lua_rawgeti(L,index,n+1);
if (lua_isnil(L,-1))break;
++n;
lua_pop(L,1);
}
lua_pop(L,1);
return n;
}
SWIGINTERN int SWIG_table_size(lua_State* L, int index)
{
int n=0;
lua_pushnil(L); /* first key*/
while (lua_next(L, index) != 0) {
++n;
lua_pop(L, 1); /* removes `value'; keeps `key' for next iteration*/
}
return n;
}
/* super macro to declare array typemap helper fns */
#define SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE)\
SWIGINTERN int SWIG_read_##NAME##_num_array(lua_State* L,int index,TYPE *array,int size){\
int i;\
for (i = 0; i < size; i++) {\
lua_rawgeti(L,index,i+1);\
if (lua_isnumber(L,-1)){\
array[i] = (TYPE)lua_tonumber(L,-1);\
} else {\
lua_pop(L,1);\
return 0;\
}\
lua_pop(L,1);\
}\
return 1;\
}\
SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_fixed(lua_State* L, int index, int size){\
TYPE *array;\
if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) {\
SWIG_Lua_pushferrstring(L,"expected a table of size %d",size);\
return 0;\
}\
array=SWIG_ALLOC_ARRAY(TYPE,size);\
if (!SWIG_read_##NAME##_num_array(L,index,array,size)){\
SWIG_Lua_pusherrstring(L,"table must contain numbers");\
SWIG_FREE_ARRAY(array);\
return 0;\
}\
return array;\
}\
SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_var(lua_State* L, int index, int* size)\
{\
TYPE *array;\
if (!lua_istable(L,index)) {\
SWIG_Lua_pusherrstring(L,"expected a table");\
return 0;\
}\
*size=SWIG_itable_size(L,index);\
if (*size<1){\
SWIG_Lua_pusherrstring(L,"table appears to be empty");\
return 0;\
}\
array=SWIG_ALLOC_ARRAY(TYPE,*size);\
if (!SWIG_read_##NAME##_num_array(L,index,array,*size)){\
SWIG_Lua_pusherrstring(L,"table must contain numbers");\
SWIG_FREE_ARRAY(array);\
return 0;\
}\
return array;\
}\
SWIGINTERN void SWIG_write_##NAME##_num_array(lua_State* L,TYPE *array,int size){\
int i;\
lua_newtable(L);\
for (i = 0; i < size; i++){\
lua_pushnumber(L,(lua_Number)array[i]);\
lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/ \
}\
}
SWIG_DECLARE_TYPEMAP_ARR_FN(schar,signed char)
SWIG_DECLARE_TYPEMAP_ARR_FN(uchar,unsigned char)
SWIG_DECLARE_TYPEMAP_ARR_FN(int,int)
SWIG_DECLARE_TYPEMAP_ARR_FN(uint,unsigned int)
SWIG_DECLARE_TYPEMAP_ARR_FN(short,short)
SWIG_DECLARE_TYPEMAP_ARR_FN(ushort,unsigned short)
SWIG_DECLARE_TYPEMAP_ARR_FN(long,long)
SWIG_DECLARE_TYPEMAP_ARR_FN(ulong,unsigned long)
SWIG_DECLARE_TYPEMAP_ARR_FN(float,float)
SWIG_DECLARE_TYPEMAP_ARR_FN(double,double)
SWIGINTERN int SWIG_read_ptr_array(lua_State* L,int index,void **array,int size,swig_type_info *type){
int i;
for (i = 0; i < size; i++) {
lua_rawgeti(L,index,i+1);
if (!lua_isuserdata(L,-1) || SWIG_ConvertPtr(L,-1,&array[i],type,0)==-1){
lua_pop(L,1);
return 0;
}
lua_pop(L,1);
}
return 1;
}
SWIGINTERN void** SWIG_get_ptr_array_fixed(lua_State* L, int index, int size,swig_type_info *type){
void **array;
if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) {
SWIG_Lua_pushferrstring(L,"expected a table of size %d",size);
return 0;
}
array=SWIG_ALLOC_ARRAY(void*,size);
if (!SWIG_read_ptr_array(L,index,array,size,type)){
SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name);
SWIG_FREE_ARRAY(array);
return 0;
}
return array;
}
SWIGINTERN void** SWIG_get_ptr_array_var(lua_State* L, int index, int* size,swig_type_info *type){
void **array;
if (!lua_istable(L,index)) {
SWIG_Lua_pusherrstring(L,"expected a table");
return 0;
}
*size=SWIG_itable_size(L,index);
if (*size<1){
SWIG_Lua_pusherrstring(L,"table appears to be empty");
return 0;
}
array=SWIG_ALLOC_ARRAY(void*,*size);
if (!SWIG_read_ptr_array(L,index,array,*size,type)){
SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name);
SWIG_FREE_ARRAY(array);
return 0;
}
return array;
}
SWIGINTERN void SWIG_write_ptr_array(lua_State* L,void **array,int size,swig_type_info *type,int own){
int i;
lua_newtable(L);
for (i = 0; i < size; i++){
SWIG_NewPointerObj(L,array[i],type,own);
lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/
}
}
#include <algorithm>
#include <string>
#include "lldb/lldb-public.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBAttachInfo.h"
#include "lldb/API/SBBlock.h"
#include "lldb/API/SBBreakpoint.h"
#include "lldb/API/SBBreakpointLocation.h"
#include "lldb/API/SBBreakpointName.h"
#include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBCommandInterpreter.h"
#include "lldb/API/SBCommandInterpreterRunOptions.h"
#include "lldb/API/SBCommandReturnObject.h"
#include "lldb/API/SBCommunication.h"
#include "lldb/API/SBCompileUnit.h"
#include "lldb/API/SBData.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBDeclaration.h"
#include "lldb/API/SBEnvironment.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBEvent.h"
#include "lldb/API/SBExecutionContext.h"
#include "lldb/API/SBExpressionOptions.h"
#include "lldb/API/SBFile.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBFileSpecList.h"
#include "lldb/API/SBFrame.h"
#include "lldb/API/SBFunction.h"
#include "lldb/API/SBHostOS.h"
#include "lldb/API/SBInstruction.h"
#include "lldb/API/SBInstructionList.h"
#include "lldb/API/SBLanguageRuntime.h"
#include "lldb/API/SBLaunchInfo.h"
#include "lldb/API/SBLineEntry.h"
#include "lldb/API/SBListener.h"
#include "lldb/API/SBMemoryRegionInfo.h"
#include "lldb/API/SBMemoryRegionInfoList.h"
#include "lldb/API/SBModule.h"
#include "lldb/API/SBModuleSpec.h"
#include "lldb/API/SBPlatform.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBProcessInfo.h"
#include "lldb/API/SBQueue.h"
#include "lldb/API/SBQueueItem.h"
#include "lldb/API/SBReproducer.h"
#include "lldb/API/SBSection.h"
#include "lldb/API/SBSourceManager.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBStringList.h"
#include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBSymbol.h"
#include "lldb/API/SBSymbolContext.h"
#include "lldb/API/SBSymbolContextList.h"
#include "lldb/API/SBTarget.h"
#include "lldb/API/SBThread.h"
#include "lldb/API/SBThreadCollection.h"
#include "lldb/API/SBThreadPlan.h"
#include "lldb/API/SBTrace.h"
#include "lldb/API/SBType.h"
#include "lldb/API/SBTypeCategory.h"
#include "lldb/API/SBTypeEnumMember.h"
#include "lldb/API/SBTypeFilter.h"
#include "lldb/API/SBTypeFormat.h"
#include "lldb/API/SBTypeNameSpecifier.h"
#include "lldb/API/SBTypeSummary.h"
#include "lldb/API/SBTypeSynthetic.h"
#include "lldb/API/SBUnixSignals.h"
#include "lldb/API/SBValue.h"
#include "lldb/API/SBValueList.h"
#include "lldb/API/SBVariablesOptions.h"
#include "lldb/API/SBWatchpoint.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/FormatVariadic.h"
#include "../bindings/lua/lua-swigsafecast.swig"
#include "../source/Plugins/ScriptInterpreter/Lua/SWIGLuaBridge.h"
// required headers for typemaps
#include "lldb/Host/File.h"
using namespace lldb_private;
using namespace lldb;
#include <stdint.h> // Use the C99 official header
SWIGINTERN std::string lldb_SBAddress___str__(lldb::SBAddress *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBBlock___str__(lldb::SBBlock *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBBreakpoint___str__(lldb::SBBreakpoint *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBBreakpointLocation___str__(lldb::SBBreakpointLocation *self){
lldb::SBStream stream;
self->GetDescription (stream, lldb::eDescriptionLevelFull);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBBreakpointName___str__(lldb::SBBreakpointName *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBCommandReturnObject___str__(lldb::SBCommandReturnObject *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN void lldb_SBCommandReturnObject_SetImmediateOutputFile__SWIG_2(lldb::SBCommandReturnObject *self,lldb::FileSP BORROWED,bool transfer_ownership){
self->SetImmediateOutputFile(BORROWED);
}
SWIGINTERN void lldb_SBCommandReturnObject_SetImmediateErrorFile__SWIG_2(lldb::SBCommandReturnObject *self,lldb::FileSP BORROWED,bool transfer_ownership){
self->SetImmediateErrorFile(BORROWED);
}
SWIGINTERN void lldb_SBCommandReturnObject_Print(lldb::SBCommandReturnObject *self,char const *str){
self->Printf("%s", str);
}
SWIGINTERN std::string lldb_SBCompileUnit___str__(lldb::SBCompileUnit *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBData___str__(lldb::SBData *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN lldb::FileSP lldb_SBDebugger_GetInputFileHandle(lldb::SBDebugger *self){
return self->GetInputFile().GetFile();
}
SWIGINTERN lldb::FileSP lldb_SBDebugger_GetOutputFileHandle(lldb::SBDebugger *self){
return self->GetOutputFile().GetFile();
}
SWIGINTERN lldb::FileSP lldb_SBDebugger_GetErrorFileHandle(lldb::SBDebugger *self){
return self->GetErrorFile().GetFile();
}
SWIGINTERN std::string lldb_SBDebugger___str__(lldb::SBDebugger *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBDeclaration___str__(lldb::SBDeclaration *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBError___str__(lldb::SBError *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN lldb::SBFile lldb_SBFile_MakeBorrowed(lldb::FileSP BORROWED){
return lldb::SBFile(BORROWED);
}
SWIGINTERN lldb::SBFile lldb_SBFile_MakeForcingIOMethods(lldb::FileSP FORCE_IO_METHODS){
return lldb::SBFile(FORCE_IO_METHODS);
}
SWIGINTERN lldb::SBFile lldb_SBFile_MakeBorrowedForcingIOMethods(lldb::FileSP BORROWED_FORCE_IO_METHODS){
return lldb::SBFile(BORROWED_FORCE_IO_METHODS);
}
SWIGINTERN std::string lldb_SBFileSpec___str__(lldb::SBFileSpec *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBFrame___str__(lldb::SBFrame *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBFunction___str__(lldb::SBFunction *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBInstruction___str__(lldb::SBInstruction *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBInstructionList___str__(lldb::SBInstructionList *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBLineEntry___str__(lldb::SBLineEntry *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBMemoryRegionInfo___str__(lldb::SBMemoryRegionInfo *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBModule___str__(lldb::SBModule *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBModuleSpec___str__(lldb::SBModuleSpec *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBModuleSpecList___str__(lldb::SBModuleSpecList *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBProcess___str__(lldb::SBProcess *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBSection___str__(lldb::SBSection *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN void lldb_SBStream_RedirectToFileHandle(lldb::SBStream *self,lldb::FileSP file,bool transfer_fh_ownership){
self->RedirectToFile(file);
}
SWIGINTERN std::string lldb_SBSymbol___str__(lldb::SBSymbol *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBSymbolContext___str__(lldb::SBSymbolContext *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBSymbolContextList___str__(lldb::SBSymbolContextList *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBTarget___str__(lldb::SBTarget *self){
lldb::SBStream stream;
self->GetDescription (stream, lldb::eDescriptionLevelBrief);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBThread___str__(lldb::SBThread *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBTypeMember___str__(lldb::SBTypeMember *self){
lldb::SBStream stream;
self->GetDescription (stream, lldb::eDescriptionLevelBrief);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBTypeMemberFunction___str__(lldb::SBTypeMemberFunction *self){
lldb::SBStream stream;
self->GetDescription (stream, lldb::eDescriptionLevelBrief);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBType___str__(lldb::SBType *self){
lldb::SBStream stream;
self->GetDescription (stream, lldb::eDescriptionLevelBrief);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBTypeCategory___str__(lldb::SBTypeCategory *self){
lldb::SBStream stream;
self->GetDescription (stream, lldb::eDescriptionLevelBrief);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBTypeEnumMember___str__(lldb::SBTypeEnumMember *self){
lldb::SBStream stream;
self->GetDescription (stream, lldb::eDescriptionLevelBrief);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBTypeFilter___str__(lldb::SBTypeFilter *self){
lldb::SBStream stream;
self->GetDescription (stream, lldb::eDescriptionLevelBrief);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBTypeFormat___str__(lldb::SBTypeFormat *self){
lldb::SBStream stream;
self->GetDescription (stream, lldb::eDescriptionLevelBrief);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBTypeNameSpecifier___str__(lldb::SBTypeNameSpecifier *self){
lldb::SBStream stream;
self->GetDescription (stream, lldb::eDescriptionLevelBrief);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBTypeSummary___str__(lldb::SBTypeSummary *self){
lldb::SBStream stream;
self->GetDescription (stream, lldb::eDescriptionLevelBrief);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBTypeSynthetic___str__(lldb::SBTypeSynthetic *self){
lldb::SBStream stream;
self->GetDescription (stream, lldb::eDescriptionLevelBrief);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBValue___str__(lldb::SBValue *self){
lldb::SBStream stream;
self->GetDescription (stream);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBValueList___str__(lldb::SBValueList *self){
lldb::SBStream description;
const size_t n = self->GetSize();
if (n)
{
for (size_t i=0; i<n; ++i)
self->GetValueAtIndex(i).GetDescription(description);
}
else
{
description.Printf("<empty> lldb.SBValueList()");
}
const char *desc = description.GetData();
size_t desc_len = description.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
--desc_len;
return std::string(desc, desc_len);
}
SWIGINTERN std::string lldb_SBWatchpoint___str__(lldb::SBWatchpoint *self){
lldb::SBStream stream;
self->GetDescription (stream, lldb::eDescriptionLevelVerbose);
const char *desc = stream.GetData();
size_t desc_len = stream.GetSize();
if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
--desc_len;
}
return std::string(desc, desc_len);
}
template <typename T> void PushSBClass(lua_State * L, T * obj);
// This function is called from Lua::CallBreakpointCallback
llvm::Expected<bool> lldb_private::LLDBSwigLuaBreakpointCallbackFunction(
lua_State * L, lldb::StackFrameSP stop_frame_sp,
lldb::BreakpointLocationSP bp_loc_sp,
const StructuredDataImpl &extra_args_impl) {
lldb::SBFrame sb_frame(stop_frame_sp);
lldb::SBBreakpointLocation sb_bp_loc(bp_loc_sp);
int nargs = 2;
lldb::SBStructuredData extra_args(extra_args_impl);
// Push the Lua wrappers
PushSBClass(L, &sb_frame);
PushSBClass(L, &sb_bp_loc);
if (extra_args.IsValid()) {
PushSBClass(L, &extra_args);
nargs++;
}
// Call into the Lua callback passing 'sb_frame' and 'sb_bp_loc'.
// Expects a boolean return.
if (lua_pcall(L, nargs, 1, 0) != LUA_OK) {
llvm::Error E = llvm::make_error<llvm::StringError>(
llvm::formatv("{0}\n", lua_tostring(L, -1)),
llvm::inconvertibleErrorCode());
// Pop error message from the stack.
lua_pop(L, 1);
return std::move(E);
}
// Boolean return from the callback
bool stop = lua_toboolean(L, -1);
lua_pop(L, 1);
return stop;
}
// This function is called from Lua::CallWatchpointCallback
llvm::Expected<bool> lldb_private::LLDBSwigLuaWatchpointCallbackFunction(
lua_State * L, lldb::StackFrameSP stop_frame_sp, lldb::WatchpointSP wp_sp) {
lldb::SBFrame sb_frame(stop_frame_sp);
lldb::SBWatchpoint sb_wp(wp_sp);
int nargs = 2;
// Push the Lua wrappers
PushSBClass(L, &sb_frame);
PushSBClass(L, &sb_wp);
// Call into the Lua callback passing 'sb_frame' and 'sb_wp'.
// Expects a boolean return.
if (lua_pcall(L, nargs, 1, 0) != LUA_OK) {
llvm::Error E = llvm::make_error<llvm::StringError>(
llvm::formatv("{0}\n", lua_tostring(L, -1)),
llvm::inconvertibleErrorCode());
// Pop error message from the stack.
lua_pop(L, 1);
return std::move(E);
}
// Boolean return from the callback
bool stop = lua_toboolean(L, -1);
lua_pop(L, 1);
return stop;
}
static void LLDBSwigLuaCallLuaLogOutputCallback(const char *str, void *baton) {
lua_State *L = (lua_State *)baton;
lua_pushlightuserdata(L, (void *)&LLDBSwigLuaCallLuaLogOutputCallback);
lua_gettable(L, LUA_REGISTRYINDEX);
// FIXME: There's no way to report errors back to the user
lua_pushstring(L, str);
lua_pcall(L, 1, 0, 0);
}
static int LLDBSwigLuaCloseFileHandle(lua_State * L) {
return luaL_error(L, "You cannot close a file handle used by lldb.");
}
#ifdef __cplusplus
extern "C" {
#endif
static int _wrap_new_string__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
std::string *result = 0 ;
SWIG_check_num_args("std::string::string",0,0)
result = (std::string *)new std::string();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_string__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
std::string *result = 0 ;
SWIG_check_num_args("std::string::string",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("std::string::string",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = (std::string *)new std::string((char const *)arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_string(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_string__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
return _wrap_new_string__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_string'\n"
" Possible C/C++ prototypes are:\n"
" std::string::string()\n"
" std::string::string(char const *)\n");
lua_error(L);return 0;
}
static int _wrap_string_size(lua_State* L) {
int SWIG_arg = 0;
std::string *arg1 = (std::string *) 0 ;
unsigned int result;
SWIG_check_num_args("std::string::size",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::size",1,"std::string const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
SWIG_fail_ptr("string_size",1,SWIGTYPE_p_std__string);
}
result = (unsigned int)((std::string const *)arg1)->size();
lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_string_length(lua_State* L) {
int SWIG_arg = 0;
std::string *arg1 = (std::string *) 0 ;
unsigned int result;
SWIG_check_num_args("std::string::length",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::length",1,"std::string const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
SWIG_fail_ptr("string_length",1,SWIGTYPE_p_std__string);
}
result = (unsigned int)((std::string const *)arg1)->length();
lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_string_empty(lua_State* L) {
int SWIG_arg = 0;
std::string *arg1 = (std::string *) 0 ;
bool result;
SWIG_check_num_args("std::string::empty",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::empty",1,"std::string const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
SWIG_fail_ptr("string_empty",1,SWIGTYPE_p_std__string);
}
result = (bool)((std::string const *)arg1)->empty();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_string_c_str(lua_State* L) {
int SWIG_arg = 0;
std::string *arg1 = (std::string *) 0 ;
char *result = 0 ;
SWIG_check_num_args("std::string::c_str",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::c_str",1,"std::string const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
SWIG_fail_ptr("string_c_str",1,SWIGTYPE_p_std__string);
}
result = (char *)((std::string const *)arg1)->c_str();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_string_data(lua_State* L) {
int SWIG_arg = 0;
std::string *arg1 = (std::string *) 0 ;
char *result = 0 ;
SWIG_check_num_args("std::string::data",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::data",1,"std::string const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
SWIG_fail_ptr("string_data",1,SWIGTYPE_p_std__string);
}
result = (char *)((std::string const *)arg1)->data();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_string_assign(lua_State* L) {
int SWIG_arg = 0;
std::string *arg1 = (std::string *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("std::string::assign",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::assign",1,"std::string *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("std::string::assign",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
SWIG_fail_ptr("string_assign",1,SWIGTYPE_p_std__string);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->assign((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_string(void *obj) {
std::string *arg1 = (std::string *) obj;
delete arg1;
}
static int _proxy__wrap_new_string(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_string);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_string_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_string_methods[]= {
{ "size", _wrap_string_size},
{ "length", _wrap_string_length},
{ "empty", _wrap_string_empty},
{ "c_str", _wrap_string_c_str},
{ "data", _wrap_string_data},
{ "assign", _wrap_string_assign},
{0,0}
};
static swig_lua_method swig_string_meta[] = {
{0,0}
};
static swig_lua_attribute swig_string_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_string_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_string_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_string_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_string_Sf_SwigStatic = {
"string",
swig_string_Sf_SwigStatic_methods,
swig_string_Sf_SwigStatic_attributes,
swig_string_Sf_SwigStatic_constants,
swig_string_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_string_bases[] = {0};
static const char *swig_string_base_names[] = {0};
static swig_lua_class _wrap_class_string = { "string", "string", &SWIGTYPE_p_std__string,_proxy__wrap_new_string, swig_delete_string, swig_string_methods, swig_string_attributes, &swig_string_Sf_SwigStatic, swig_string_meta, swig_string_bases, swig_string_base_names };
static int _wrap_new_SBAddress__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *result = 0 ;
SWIG_check_num_args("lldb::SBAddress::SBAddress",0,0)
result = (lldb::SBAddress *)new lldb::SBAddress();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBAddress__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = 0 ;
lldb::SBAddress *result = 0 ;
SWIG_check_num_args("lldb::SBAddress::SBAddress",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBAddress::SBAddress",1,"lldb::SBAddress const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("new_SBAddress",1,SWIGTYPE_p_lldb__SBAddress);
}
result = (lldb::SBAddress *)new lldb::SBAddress((lldb::SBAddress const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBAddress__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection arg1 ;
lldb::addr_t arg2 ;
lldb::SBSection *argp1 ;
lldb::SBAddress *result = 0 ;
SWIG_check_num_args("lldb::SBAddress::SBAddress",2,2)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBAddress::SBAddress",1,"lldb::SBSection");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAddress::SBAddress",2,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("new_SBAddress",1,SWIGTYPE_p_lldb__SBSection);
}
arg1 = *argp1;
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
result = (lldb::SBAddress *)new lldb::SBAddress(arg1,arg2);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBAddress__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
lldb::addr_t arg1 ;
lldb::SBTarget *arg2 = 0 ;
lldb::SBAddress *result = 0 ;
SWIG_check_num_args("lldb::SBAddress::SBAddress",2,2)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBAddress::SBAddress",1,"lldb::addr_t");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAddress::SBAddress",2,"lldb::SBTarget &");
arg1 = (lldb::addr_t)lua_tointeger(L, 1);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("new_SBAddress",2,SWIGTYPE_p_lldb__SBTarget);
}
result = (lldb::SBAddress *)new lldb::SBAddress(arg1,*arg2);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBAddress(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBAddress__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBAddress__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSection, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_new_SBAddress__SWIG_2(L);
}
}
}
if (argc == 2) {
int _v;
{
_v = lua_isnumber(L,argv[0]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBAddress__SWIG_3(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBAddress'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBAddress::SBAddress()\n"
" lldb::SBAddress::SBAddress(lldb::SBAddress const &)\n"
" lldb::SBAddress::SBAddress(lldb::SBSection,lldb::addr_t)\n"
" lldb::SBAddress::SBAddress(lldb::addr_t,lldb::SBTarget &)\n");
lua_error(L);return 0;
}
static int _wrap_SBAddress_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBAddress::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::IsValid",1,"lldb::SBAddress const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBAddress_IsValid",1,SWIGTYPE_p_lldb__SBAddress);
}
result = (bool)((lldb::SBAddress const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAddress_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
SWIG_check_num_args("lldb::SBAddress::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::Clear",1,"lldb::SBAddress *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBAddress_Clear",1,SWIGTYPE_p_lldb__SBAddress);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAddress_GetFileAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBAddress::GetFileAddress",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetFileAddress",1,"lldb::SBAddress const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBAddress_GetFileAddress",1,SWIGTYPE_p_lldb__SBAddress);
}
result = (lldb::addr_t)((lldb::SBAddress const *)arg1)->GetFileAddress();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAddress_GetLoadAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
lldb::SBTarget *arg2 = 0 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBAddress::GetLoadAddress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetLoadAddress",1,"lldb::SBAddress const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAddress::GetLoadAddress",2,"lldb::SBTarget const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBAddress_GetLoadAddress",1,SWIGTYPE_p_lldb__SBAddress);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBAddress_GetLoadAddress",2,SWIGTYPE_p_lldb__SBTarget);
}
result = (lldb::addr_t)((lldb::SBAddress const *)arg1)->GetLoadAddress((lldb::SBTarget const &)*arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAddress_SetLoadAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
lldb::addr_t arg2 ;
lldb::SBTarget *arg3 = 0 ;
SWIG_check_num_args("lldb::SBAddress::SetLoadAddress",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::SetLoadAddress",1,"lldb::SBAddress *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAddress::SetLoadAddress",2,"lldb::addr_t");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBAddress::SetLoadAddress",3,"lldb::SBTarget &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBAddress_SetLoadAddress",1,SWIGTYPE_p_lldb__SBAddress);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBAddress_SetLoadAddress",3,SWIGTYPE_p_lldb__SBTarget);
}
(arg1)->SetLoadAddress(arg2,*arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAddress_OffsetAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
lldb::addr_t arg2 ;
bool result;
SWIG_check_num_args("lldb::SBAddress::OffsetAddress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::OffsetAddress",1,"lldb::SBAddress *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAddress::OffsetAddress",2,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBAddress_OffsetAddress",1,SWIGTYPE_p_lldb__SBAddress);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
result = (bool)(arg1)->OffsetAddress(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAddress_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBAddress::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetDescription",1,"lldb::SBAddress *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAddress::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBAddress_GetDescription",1,SWIGTYPE_p_lldb__SBAddress);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBAddress_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAddress_GetSection(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
lldb::SBSection result;
SWIG_check_num_args("lldb::SBAddress::GetSection",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetSection",1,"lldb::SBAddress *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBAddress_GetSection",1,SWIGTYPE_p_lldb__SBAddress);
}
result = (arg1)->GetSection();
{
lldb::SBSection * resultptr = new lldb::SBSection((const lldb::SBSection &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSection,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAddress_GetOffset(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBAddress::GetOffset",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetOffset",1,"lldb::SBAddress *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBAddress_GetOffset",1,SWIGTYPE_p_lldb__SBAddress);
}
result = (lldb::addr_t)(arg1)->GetOffset();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAddress_SetAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
lldb::SBSection arg2 ;
lldb::addr_t arg3 ;
lldb::SBSection *argp2 ;
SWIG_check_num_args("lldb::SBAddress::SetAddress",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::SetAddress",1,"lldb::SBAddress *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAddress::SetAddress",2,"lldb::SBSection");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBAddress::SetAddress",3,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBAddress_SetAddress",1,SWIGTYPE_p_lldb__SBAddress);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBAddress_SetAddress",2,SWIGTYPE_p_lldb__SBSection);
}
arg2 = *argp2;
arg3 = (lldb::addr_t)lua_tointeger(L, 3);
(arg1)->SetAddress(arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAddress_GetSymbolContext(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
uint32_t arg2 ;
lldb::SBSymbolContext result;
SWIG_check_num_args("lldb::SBAddress::GetSymbolContext",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetSymbolContext",1,"lldb::SBAddress *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAddress::GetSymbolContext",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBAddress_GetSymbolContext",1,SWIGTYPE_p_lldb__SBAddress);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetSymbolContext(arg2);
{
lldb::SBSymbolContext * resultptr = new lldb::SBSymbolContext((const lldb::SBSymbolContext &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContext,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAddress_GetModule(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
lldb::SBModule result;
SWIG_check_num_args("lldb::SBAddress::GetModule",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetModule",1,"lldb::SBAddress *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBAddress_GetModule",1,SWIGTYPE_p_lldb__SBAddress);
}
result = (arg1)->GetModule();
{
lldb::SBModule * resultptr = new lldb::SBModule((const lldb::SBModule &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAddress_GetCompileUnit(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
lldb::SBCompileUnit result;
SWIG_check_num_args("lldb::SBAddress::GetCompileUnit",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetCompileUnit",1,"lldb::SBAddress *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBAddress_GetCompileUnit",1,SWIGTYPE_p_lldb__SBAddress);
}
result = (arg1)->GetCompileUnit();
{
lldb::SBCompileUnit * resultptr = new lldb::SBCompileUnit((const lldb::SBCompileUnit &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBCompileUnit,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAddress_GetFunction(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
lldb::SBFunction result;
SWIG_check_num_args("lldb::SBAddress::GetFunction",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetFunction",1,"lldb::SBAddress *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBAddress_GetFunction",1,SWIGTYPE_p_lldb__SBAddress);
}
result = (arg1)->GetFunction();
{
lldb::SBFunction * resultptr = new lldb::SBFunction((const lldb::SBFunction &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFunction,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAddress_GetBlock(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
lldb::SBBlock result;
SWIG_check_num_args("lldb::SBAddress::GetBlock",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetBlock",1,"lldb::SBAddress *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBAddress_GetBlock",1,SWIGTYPE_p_lldb__SBAddress);
}
result = (arg1)->GetBlock();
{
lldb::SBBlock * resultptr = new lldb::SBBlock((const lldb::SBBlock &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAddress_GetSymbol(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
lldb::SBSymbol result;
SWIG_check_num_args("lldb::SBAddress::GetSymbol",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetSymbol",1,"lldb::SBAddress *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBAddress_GetSymbol",1,SWIGTYPE_p_lldb__SBAddress);
}
result = (arg1)->GetSymbol();
{
lldb::SBSymbol * resultptr = new lldb::SBSymbol((const lldb::SBSymbol &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbol,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAddress_GetLineEntry(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
lldb::SBLineEntry result;
SWIG_check_num_args("lldb::SBAddress::GetLineEntry",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetLineEntry",1,"lldb::SBAddress *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBAddress_GetLineEntry",1,SWIGTYPE_p_lldb__SBAddress);
}
result = (arg1)->GetLineEntry();
{
lldb::SBLineEntry * resultptr = new lldb::SBLineEntry((const lldb::SBLineEntry &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBLineEntry,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAddress___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBAddress::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::__str__",1,"lldb::SBAddress *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBAddress___tostring",1,SWIGTYPE_p_lldb__SBAddress);
}
result = lldb_SBAddress___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBAddress(void *obj) {
lldb::SBAddress *arg1 = (lldb::SBAddress *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBAddress(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBAddress);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBAddress_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBAddress_methods[]= {
{ "IsValid", _wrap_SBAddress_IsValid},
{ "Clear", _wrap_SBAddress_Clear},
{ "GetFileAddress", _wrap_SBAddress_GetFileAddress},
{ "GetLoadAddress", _wrap_SBAddress_GetLoadAddress},
{ "SetLoadAddress", _wrap_SBAddress_SetLoadAddress},
{ "OffsetAddress", _wrap_SBAddress_OffsetAddress},
{ "GetDescription", _wrap_SBAddress_GetDescription},
{ "GetSection", _wrap_SBAddress_GetSection},
{ "GetOffset", _wrap_SBAddress_GetOffset},
{ "SetAddress", _wrap_SBAddress_SetAddress},
{ "GetSymbolContext", _wrap_SBAddress_GetSymbolContext},
{ "GetModule", _wrap_SBAddress_GetModule},
{ "GetCompileUnit", _wrap_SBAddress_GetCompileUnit},
{ "GetFunction", _wrap_SBAddress_GetFunction},
{ "GetBlock", _wrap_SBAddress_GetBlock},
{ "GetSymbol", _wrap_SBAddress_GetSymbol},
{ "GetLineEntry", _wrap_SBAddress_GetLineEntry},
{ "__tostring", _wrap_SBAddress___tostring},
{0,0}
};
static swig_lua_method swig_SBAddress_meta[] = {
{ "__tostring", _wrap_SBAddress___tostring},
{0,0}
};
static swig_lua_attribute swig_SBAddress_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBAddress_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBAddress_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBAddress_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBAddress_Sf_SwigStatic = {
"SBAddress",
swig_SBAddress_Sf_SwigStatic_methods,
swig_SBAddress_Sf_SwigStatic_attributes,
swig_SBAddress_Sf_SwigStatic_constants,
swig_SBAddress_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBAddress_bases[] = {0};
static const char *swig_SBAddress_base_names[] = {0};
static swig_lua_class _wrap_class_SBAddress = { "SBAddress", "SBAddress", &SWIGTYPE_p_lldb__SBAddress,_proxy__wrap_new_SBAddress, swig_delete_SBAddress, swig_SBAddress_methods, swig_SBAddress_attributes, &swig_SBAddress_Sf_SwigStatic, swig_SBAddress_meta, swig_SBAddress_bases, swig_SBAddress_base_names };
static int _wrap_new_SBAttachInfo__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *result = 0 ;
SWIG_check_num_args("lldb::SBAttachInfo::SBAttachInfo",0,0)
result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAttachInfo,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBAttachInfo__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::pid_t arg1 ;
lldb::SBAttachInfo *result = 0 ;
SWIG_check_num_args("lldb::SBAttachInfo::SBAttachInfo",1,1)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SBAttachInfo",1,"lldb::pid_t");
arg1 = (lldb::pid_t)lua_tointeger(L, 1);
result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo(arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAttachInfo,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBAttachInfo__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
bool arg2 ;
lldb::SBAttachInfo *result = 0 ;
SWIG_check_num_args("lldb::SBAttachInfo::SBAttachInfo",2,2)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SBAttachInfo",1,"char const *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SBAttachInfo",2,"bool");
arg1 = (char *)lua_tostring(L, 1);
arg2 = (lua_toboolean(L, 2)!=0);
result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo((char const *)arg1,arg2);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAttachInfo,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBAttachInfo__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
bool arg2 ;
bool arg3 ;
lldb::SBAttachInfo *result = 0 ;
SWIG_check_num_args("lldb::SBAttachInfo::SBAttachInfo",3,3)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SBAttachInfo",1,"char const *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SBAttachInfo",2,"bool");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBAttachInfo::SBAttachInfo",3,"bool");
arg1 = (char *)lua_tostring(L, 1);
arg2 = (lua_toboolean(L, 2)!=0);
arg3 = (lua_toboolean(L, 3)!=0);
result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo((char const *)arg1,arg2,arg3);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAttachInfo,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBAttachInfo__SWIG_4(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = 0 ;
lldb::SBAttachInfo *result = 0 ;
SWIG_check_num_args("lldb::SBAttachInfo::SBAttachInfo",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SBAttachInfo",1,"lldb::SBAttachInfo const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("new_SBAttachInfo",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo((lldb::SBAttachInfo const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAttachInfo,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBAttachInfo(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBAttachInfo__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBAttachInfo__SWIG_4(L);
}
}
if (argc == 1) {
int _v;
{
_v = lua_isnumber(L,argv[0]);
}
if (_v) {
return _wrap_new_SBAttachInfo__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_new_SBAttachInfo__SWIG_2(L);
}
}
}
if (argc == 3) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[2]);
}
if (_v) {
return _wrap_new_SBAttachInfo__SWIG_3(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBAttachInfo'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBAttachInfo::SBAttachInfo()\n"
" lldb::SBAttachInfo::SBAttachInfo(lldb::pid_t)\n"
" lldb::SBAttachInfo::SBAttachInfo(char const *,bool)\n"
" lldb::SBAttachInfo::SBAttachInfo(char const *,bool,bool)\n"
" lldb::SBAttachInfo::SBAttachInfo(lldb::SBAttachInfo const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBAttachInfo_GetProcessID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
lldb::pid_t result;
SWIG_check_num_args("lldb::SBAttachInfo::GetProcessID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetProcessID",1,"lldb::SBAttachInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_GetProcessID",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
result = (lldb::pid_t)(arg1)->GetProcessID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_SetProcessID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
lldb::pid_t arg2 ;
SWIG_check_num_args("lldb::SBAttachInfo::SetProcessID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetProcessID",1,"lldb::SBAttachInfo *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetProcessID",2,"lldb::pid_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_SetProcessID",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
arg2 = (lldb::pid_t)lua_tointeger(L, 2);
(arg1)->SetProcessID(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_SetExecutable__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBAttachInfo::SetExecutable",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetExecutable",1,"lldb::SBAttachInfo *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetExecutable",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_SetExecutable",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetExecutable((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_SetExecutable__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
lldb::SBFileSpec arg2 ;
lldb::SBFileSpec *argp2 ;
SWIG_check_num_args("lldb::SBAttachInfo::SetExecutable",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetExecutable",1,"lldb::SBAttachInfo *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetExecutable",2,"lldb::SBFileSpec");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_SetExecutable",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBAttachInfo_SetExecutable",2,SWIGTYPE_p_lldb__SBFileSpec);
}
arg2 = *argp2;
(arg1)->SetExecutable(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_SetExecutable(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBAttachInfo, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBAttachInfo_SetExecutable__SWIG_1(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBAttachInfo, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBAttachInfo_SetExecutable__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBAttachInfo_SetExecutable'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBAttachInfo::SetExecutable(char const *)\n"
" lldb::SBAttachInfo::SetExecutable(lldb::SBFileSpec)\n");
lua_error(L);return 0;
}
static int _wrap_SBAttachInfo_GetWaitForLaunch(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBAttachInfo::GetWaitForLaunch",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetWaitForLaunch",1,"lldb::SBAttachInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_GetWaitForLaunch",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
result = (bool)(arg1)->GetWaitForLaunch();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_SetWaitForLaunch__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBAttachInfo::SetWaitForLaunch",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetWaitForLaunch",1,"lldb::SBAttachInfo *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetWaitForLaunch",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_SetWaitForLaunch",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetWaitForLaunch(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_SetWaitForLaunch__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
bool arg2 ;
bool arg3 ;
SWIG_check_num_args("lldb::SBAttachInfo::SetWaitForLaunch",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetWaitForLaunch",1,"lldb::SBAttachInfo *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetWaitForLaunch",2,"bool");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBAttachInfo::SetWaitForLaunch",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_SetWaitForLaunch",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
arg2 = (lua_toboolean(L, 2)!=0);
arg3 = (lua_toboolean(L, 3)!=0);
(arg1)->SetWaitForLaunch(arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_SetWaitForLaunch(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBAttachInfo, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_SBAttachInfo_SetWaitForLaunch__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBAttachInfo, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[2]);
}
if (_v) {
return _wrap_SBAttachInfo_SetWaitForLaunch__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBAttachInfo_SetWaitForLaunch'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBAttachInfo::SetWaitForLaunch(bool)\n"
" lldb::SBAttachInfo::SetWaitForLaunch(bool,bool)\n");
lua_error(L);return 0;
}
static int _wrap_SBAttachInfo_GetIgnoreExisting(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBAttachInfo::GetIgnoreExisting",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetIgnoreExisting",1,"lldb::SBAttachInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_GetIgnoreExisting",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
result = (bool)(arg1)->GetIgnoreExisting();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_SetIgnoreExisting(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBAttachInfo::SetIgnoreExisting",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetIgnoreExisting",1,"lldb::SBAttachInfo *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetIgnoreExisting",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_SetIgnoreExisting",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetIgnoreExisting(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_GetResumeCount(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBAttachInfo::GetResumeCount",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetResumeCount",1,"lldb::SBAttachInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_GetResumeCount",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
result = (uint32_t)(arg1)->GetResumeCount();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_SetResumeCount(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBAttachInfo::SetResumeCount",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetResumeCount",1,"lldb::SBAttachInfo *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetResumeCount",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_SetResumeCount",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetResumeCount(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_GetProcessPluginName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBAttachInfo::GetProcessPluginName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetProcessPluginName",1,"lldb::SBAttachInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_GetProcessPluginName",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
result = (char *)(arg1)->GetProcessPluginName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_SetProcessPluginName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBAttachInfo::SetProcessPluginName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetProcessPluginName",1,"lldb::SBAttachInfo *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetProcessPluginName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_SetProcessPluginName",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetProcessPluginName((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_GetUserID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBAttachInfo::GetUserID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetUserID",1,"lldb::SBAttachInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_GetUserID",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
result = (uint32_t)(arg1)->GetUserID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_GetGroupID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBAttachInfo::GetGroupID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetGroupID",1,"lldb::SBAttachInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_GetGroupID",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
result = (uint32_t)(arg1)->GetGroupID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_UserIDIsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBAttachInfo::UserIDIsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::UserIDIsValid",1,"lldb::SBAttachInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_UserIDIsValid",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
result = (bool)(arg1)->UserIDIsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_GroupIDIsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBAttachInfo::GroupIDIsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GroupIDIsValid",1,"lldb::SBAttachInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_GroupIDIsValid",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
result = (bool)(arg1)->GroupIDIsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_SetUserID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBAttachInfo::SetUserID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetUserID",1,"lldb::SBAttachInfo *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetUserID",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_SetUserID",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetUserID(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_SetGroupID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBAttachInfo::SetGroupID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetGroupID",1,"lldb::SBAttachInfo *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetGroupID",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_SetGroupID",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetGroupID(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_GetEffectiveUserID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBAttachInfo::GetEffectiveUserID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetEffectiveUserID",1,"lldb::SBAttachInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_GetEffectiveUserID",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
result = (uint32_t)(arg1)->GetEffectiveUserID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_GetEffectiveGroupID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBAttachInfo::GetEffectiveGroupID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetEffectiveGroupID",1,"lldb::SBAttachInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_GetEffectiveGroupID",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
result = (uint32_t)(arg1)->GetEffectiveGroupID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_EffectiveUserIDIsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBAttachInfo::EffectiveUserIDIsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::EffectiveUserIDIsValid",1,"lldb::SBAttachInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_EffectiveUserIDIsValid",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
result = (bool)(arg1)->EffectiveUserIDIsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_EffectiveGroupIDIsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBAttachInfo::EffectiveGroupIDIsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::EffectiveGroupIDIsValid",1,"lldb::SBAttachInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_EffectiveGroupIDIsValid",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
result = (bool)(arg1)->EffectiveGroupIDIsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_SetEffectiveUserID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBAttachInfo::SetEffectiveUserID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetEffectiveUserID",1,"lldb::SBAttachInfo *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetEffectiveUserID",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_SetEffectiveUserID",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetEffectiveUserID(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_SetEffectiveGroupID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBAttachInfo::SetEffectiveGroupID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetEffectiveGroupID",1,"lldb::SBAttachInfo *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetEffectiveGroupID",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_SetEffectiveGroupID",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetEffectiveGroupID(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_GetParentProcessID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
lldb::pid_t result;
SWIG_check_num_args("lldb::SBAttachInfo::GetParentProcessID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetParentProcessID",1,"lldb::SBAttachInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_GetParentProcessID",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
result = (lldb::pid_t)(arg1)->GetParentProcessID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_SetParentProcessID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
lldb::pid_t arg2 ;
SWIG_check_num_args("lldb::SBAttachInfo::SetParentProcessID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetParentProcessID",1,"lldb::SBAttachInfo *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetParentProcessID",2,"lldb::pid_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_SetParentProcessID",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
arg2 = (lldb::pid_t)lua_tointeger(L, 2);
(arg1)->SetParentProcessID(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_ParentProcessIDIsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBAttachInfo::ParentProcessIDIsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::ParentProcessIDIsValid",1,"lldb::SBAttachInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_ParentProcessIDIsValid",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
result = (bool)(arg1)->ParentProcessIDIsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_GetListener(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
lldb::SBListener result;
SWIG_check_num_args("lldb::SBAttachInfo::GetListener",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetListener",1,"lldb::SBAttachInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_GetListener",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
result = (arg1)->GetListener();
{
lldb::SBListener * resultptr = new lldb::SBListener((const lldb::SBListener &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBListener,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBAttachInfo_SetListener(lua_State* L) {
int SWIG_arg = 0;
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
lldb::SBListener *arg2 = 0 ;
SWIG_check_num_args("lldb::SBAttachInfo::SetListener",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetListener",1,"lldb::SBAttachInfo *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetListener",2,"lldb::SBListener &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBAttachInfo_SetListener",1,SWIGTYPE_p_lldb__SBAttachInfo);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBAttachInfo_SetListener",2,SWIGTYPE_p_lldb__SBListener);
}
(arg1)->SetListener(*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBAttachInfo(void *obj) {
lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBAttachInfo(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBAttachInfo);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBAttachInfo_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBAttachInfo_methods[]= {
{ "GetProcessID", _wrap_SBAttachInfo_GetProcessID},
{ "SetProcessID", _wrap_SBAttachInfo_SetProcessID},
{ "SetExecutable", _wrap_SBAttachInfo_SetExecutable},
{ "GetWaitForLaunch", _wrap_SBAttachInfo_GetWaitForLaunch},
{ "SetWaitForLaunch", _wrap_SBAttachInfo_SetWaitForLaunch},
{ "GetIgnoreExisting", _wrap_SBAttachInfo_GetIgnoreExisting},
{ "SetIgnoreExisting", _wrap_SBAttachInfo_SetIgnoreExisting},
{ "GetResumeCount", _wrap_SBAttachInfo_GetResumeCount},
{ "SetResumeCount", _wrap_SBAttachInfo_SetResumeCount},
{ "GetProcessPluginName", _wrap_SBAttachInfo_GetProcessPluginName},
{ "SetProcessPluginName", _wrap_SBAttachInfo_SetProcessPluginName},
{ "GetUserID", _wrap_SBAttachInfo_GetUserID},
{ "GetGroupID", _wrap_SBAttachInfo_GetGroupID},
{ "UserIDIsValid", _wrap_SBAttachInfo_UserIDIsValid},
{ "GroupIDIsValid", _wrap_SBAttachInfo_GroupIDIsValid},
{ "SetUserID", _wrap_SBAttachInfo_SetUserID},
{ "SetGroupID", _wrap_SBAttachInfo_SetGroupID},
{ "GetEffectiveUserID", _wrap_SBAttachInfo_GetEffectiveUserID},
{ "GetEffectiveGroupID", _wrap_SBAttachInfo_GetEffectiveGroupID},
{ "EffectiveUserIDIsValid", _wrap_SBAttachInfo_EffectiveUserIDIsValid},
{ "EffectiveGroupIDIsValid", _wrap_SBAttachInfo_EffectiveGroupIDIsValid},
{ "SetEffectiveUserID", _wrap_SBAttachInfo_SetEffectiveUserID},
{ "SetEffectiveGroupID", _wrap_SBAttachInfo_SetEffectiveGroupID},
{ "GetParentProcessID", _wrap_SBAttachInfo_GetParentProcessID},
{ "SetParentProcessID", _wrap_SBAttachInfo_SetParentProcessID},
{ "ParentProcessIDIsValid", _wrap_SBAttachInfo_ParentProcessIDIsValid},
{ "GetListener", _wrap_SBAttachInfo_GetListener},
{ "SetListener", _wrap_SBAttachInfo_SetListener},
{0,0}
};
static swig_lua_method swig_SBAttachInfo_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBAttachInfo_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBAttachInfo_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBAttachInfo_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBAttachInfo_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBAttachInfo_Sf_SwigStatic = {
"SBAttachInfo",
swig_SBAttachInfo_Sf_SwigStatic_methods,
swig_SBAttachInfo_Sf_SwigStatic_attributes,
swig_SBAttachInfo_Sf_SwigStatic_constants,
swig_SBAttachInfo_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBAttachInfo_bases[] = {0};
static const char *swig_SBAttachInfo_base_names[] = {0};
static swig_lua_class _wrap_class_SBAttachInfo = { "SBAttachInfo", "SBAttachInfo", &SWIGTYPE_p_lldb__SBAttachInfo,_proxy__wrap_new_SBAttachInfo, swig_delete_SBAttachInfo, swig_SBAttachInfo_methods, swig_SBAttachInfo_attributes, &swig_SBAttachInfo_Sf_SwigStatic, swig_SBAttachInfo_meta, swig_SBAttachInfo_bases, swig_SBAttachInfo_base_names };
static int _wrap_new_SBBlock__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *result = 0 ;
SWIG_check_num_args("lldb::SBBlock::SBBlock",0,0)
result = (lldb::SBBlock *)new lldb::SBBlock();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBBlock__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = 0 ;
lldb::SBBlock *result = 0 ;
SWIG_check_num_args("lldb::SBBlock::SBBlock",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBlock::SBBlock",1,"lldb::SBBlock const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("new_SBBlock",1,SWIGTYPE_p_lldb__SBBlock);
}
result = (lldb::SBBlock *)new lldb::SBBlock((lldb::SBBlock const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBBlock(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBBlock__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBBlock__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBBlock'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBBlock::SBBlock()\n"
" lldb::SBBlock::SBBlock(lldb::SBBlock const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBBlock_IsInlined(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBlock::IsInlined",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::IsInlined",1,"lldb::SBBlock const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBBlock_IsInlined",1,SWIGTYPE_p_lldb__SBBlock);
}
result = (bool)((lldb::SBBlock const *)arg1)->IsInlined();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBlock_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBlock::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::IsValid",1,"lldb::SBBlock const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBBlock_IsValid",1,SWIGTYPE_p_lldb__SBBlock);
}
result = (bool)((lldb::SBBlock const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBlock_GetInlinedName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBBlock::GetInlinedName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetInlinedName",1,"lldb::SBBlock const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBBlock_GetInlinedName",1,SWIGTYPE_p_lldb__SBBlock);
}
result = (char *)((lldb::SBBlock const *)arg1)->GetInlinedName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBlock_GetInlinedCallSiteFile(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBBlock::GetInlinedCallSiteFile",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetInlinedCallSiteFile",1,"lldb::SBBlock const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBBlock_GetInlinedCallSiteFile",1,SWIGTYPE_p_lldb__SBBlock);
}
result = ((lldb::SBBlock const *)arg1)->GetInlinedCallSiteFile();
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBlock_GetInlinedCallSiteLine(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBBlock::GetInlinedCallSiteLine",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetInlinedCallSiteLine",1,"lldb::SBBlock const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBBlock_GetInlinedCallSiteLine",1,SWIGTYPE_p_lldb__SBBlock);
}
result = (uint32_t)((lldb::SBBlock const *)arg1)->GetInlinedCallSiteLine();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBlock_GetInlinedCallSiteColumn(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBBlock::GetInlinedCallSiteColumn",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetInlinedCallSiteColumn",1,"lldb::SBBlock const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBBlock_GetInlinedCallSiteColumn",1,SWIGTYPE_p_lldb__SBBlock);
}
result = (uint32_t)((lldb::SBBlock const *)arg1)->GetInlinedCallSiteColumn();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBlock_GetParent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
lldb::SBBlock result;
SWIG_check_num_args("lldb::SBBlock::GetParent",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetParent",1,"lldb::SBBlock *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBBlock_GetParent",1,SWIGTYPE_p_lldb__SBBlock);
}
result = (arg1)->GetParent();
{
lldb::SBBlock * resultptr = new lldb::SBBlock((const lldb::SBBlock &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBlock_GetContainingInlinedBlock(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
lldb::SBBlock result;
SWIG_check_num_args("lldb::SBBlock::GetContainingInlinedBlock",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetContainingInlinedBlock",1,"lldb::SBBlock *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBBlock_GetContainingInlinedBlock",1,SWIGTYPE_p_lldb__SBBlock);
}
result = (arg1)->GetContainingInlinedBlock();
{
lldb::SBBlock * resultptr = new lldb::SBBlock((const lldb::SBBlock &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBlock_GetSibling(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
lldb::SBBlock result;
SWIG_check_num_args("lldb::SBBlock::GetSibling",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetSibling",1,"lldb::SBBlock *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBBlock_GetSibling",1,SWIGTYPE_p_lldb__SBBlock);
}
result = (arg1)->GetSibling();
{
lldb::SBBlock * resultptr = new lldb::SBBlock((const lldb::SBBlock &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBlock_GetFirstChild(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
lldb::SBBlock result;
SWIG_check_num_args("lldb::SBBlock::GetFirstChild",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetFirstChild",1,"lldb::SBBlock *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBBlock_GetFirstChild",1,SWIGTYPE_p_lldb__SBBlock);
}
result = (arg1)->GetFirstChild();
{
lldb::SBBlock * resultptr = new lldb::SBBlock((const lldb::SBBlock &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBlock_GetNumRanges(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBBlock::GetNumRanges",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetNumRanges",1,"lldb::SBBlock *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBBlock_GetNumRanges",1,SWIGTYPE_p_lldb__SBBlock);
}
result = (uint32_t)(arg1)->GetNumRanges();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBlock_GetRangeStartAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
uint32_t arg2 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBBlock::GetRangeStartAddress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetRangeStartAddress",1,"lldb::SBBlock *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBlock::GetRangeStartAddress",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBBlock_GetRangeStartAddress",1,SWIGTYPE_p_lldb__SBBlock);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetRangeStartAddress(arg2);
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBlock_GetRangeEndAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
uint32_t arg2 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBBlock::GetRangeEndAddress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetRangeEndAddress",1,"lldb::SBBlock *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBlock::GetRangeEndAddress",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBBlock_GetRangeEndAddress",1,SWIGTYPE_p_lldb__SBBlock);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetRangeEndAddress(arg2);
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBlock_GetRangeIndexForBlockAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
lldb::SBAddress arg2 ;
lldb::SBAddress *argp2 ;
uint32_t result;
SWIG_check_num_args("lldb::SBBlock::GetRangeIndexForBlockAddress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetRangeIndexForBlockAddress",1,"lldb::SBBlock *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBlock::GetRangeIndexForBlockAddress",2,"lldb::SBAddress");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBBlock_GetRangeIndexForBlockAddress",1,SWIGTYPE_p_lldb__SBBlock);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBBlock_GetRangeIndexForBlockAddress",2,SWIGTYPE_p_lldb__SBAddress);
}
arg2 = *argp2;
result = (uint32_t)(arg1)->GetRangeIndexForBlockAddress(arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBlock_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBBlock::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetDescription",1,"lldb::SBBlock *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBlock::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBBlock_GetDescription",1,SWIGTYPE_p_lldb__SBBlock);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBBlock_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBlock_GetVariables__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
lldb::SBFrame *arg2 = 0 ;
bool arg3 ;
bool arg4 ;
bool arg5 ;
lldb::DynamicValueType arg6 ;
lldb::SBValueList result;
SWIG_check_num_args("lldb::SBBlock::GetVariables",6,6)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetVariables",1,"lldb::SBBlock *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBlock::GetVariables",2,"lldb::SBFrame &");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBBlock::GetVariables",3,"bool");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBBlock::GetVariables",4,"bool");
if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBBlock::GetVariables",5,"bool");
if(!lua_isinteger(L,6)) SWIG_fail_arg("lldb::SBBlock::GetVariables",6,"lldb::DynamicValueType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBBlock_GetVariables",1,SWIGTYPE_p_lldb__SBBlock);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBBlock_GetVariables",2,SWIGTYPE_p_lldb__SBFrame);
}
arg3 = (lua_toboolean(L, 3)!=0);
arg4 = (lua_toboolean(L, 4)!=0);
arg5 = (lua_toboolean(L, 5)!=0);
arg6 = (lldb::DynamicValueType)lua_tointeger(L, 6);
result = (arg1)->GetVariables(*arg2,arg3,arg4,arg5,arg6);
{
lldb::SBValueList * resultptr = new lldb::SBValueList((const lldb::SBValueList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBlock_GetVariables__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
lldb::SBTarget *arg2 = 0 ;
bool arg3 ;
bool arg4 ;
bool arg5 ;
lldb::SBValueList result;
SWIG_check_num_args("lldb::SBBlock::GetVariables",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetVariables",1,"lldb::SBBlock *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBlock::GetVariables",2,"lldb::SBTarget &");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBBlock::GetVariables",3,"bool");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBBlock::GetVariables",4,"bool");
if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBBlock::GetVariables",5,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBBlock_GetVariables",1,SWIGTYPE_p_lldb__SBBlock);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBBlock_GetVariables",2,SWIGTYPE_p_lldb__SBTarget);
}
arg3 = (lua_toboolean(L, 3)!=0);
arg4 = (lua_toboolean(L, 4)!=0);
arg5 = (lua_toboolean(L, 5)!=0);
result = (arg1)->GetVariables(*arg2,arg3,arg4,arg5);
{
lldb::SBValueList * resultptr = new lldb::SBValueList((const lldb::SBValueList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBlock_GetVariables(lua_State* L) {
int argc;
int argv[7]={
1,2,3,4,5,6,7
};
argc = lua_gettop(L);
if (argc == 5) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBlock, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[2]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[3]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[4]);
}
if (_v) {
return _wrap_SBBlock_GetVariables__SWIG_1(L);
}
}
}
}
}
}
if (argc == 6) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBlock, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[2]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[3]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[4]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[5]);
}
if (_v) {
return _wrap_SBBlock_GetVariables__SWIG_0(L);
}
}
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBBlock_GetVariables'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBBlock::GetVariables(lldb::SBFrame &,bool,bool,bool,lldb::DynamicValueType)\n"
" lldb::SBBlock::GetVariables(lldb::SBTarget &,bool,bool,bool)\n");
lua_error(L);return 0;
}
static int _wrap_SBBlock___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBBlock::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::__str__",1,"lldb::SBBlock *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBBlock___tostring",1,SWIGTYPE_p_lldb__SBBlock);
}
result = lldb_SBBlock___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBBlock(void *obj) {
lldb::SBBlock *arg1 = (lldb::SBBlock *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBBlock(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBBlock);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBBlock_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBBlock_methods[]= {
{ "IsInlined", _wrap_SBBlock_IsInlined},
{ "IsValid", _wrap_SBBlock_IsValid},
{ "GetInlinedName", _wrap_SBBlock_GetInlinedName},
{ "GetInlinedCallSiteFile", _wrap_SBBlock_GetInlinedCallSiteFile},
{ "GetInlinedCallSiteLine", _wrap_SBBlock_GetInlinedCallSiteLine},
{ "GetInlinedCallSiteColumn", _wrap_SBBlock_GetInlinedCallSiteColumn},
{ "GetParent", _wrap_SBBlock_GetParent},
{ "GetContainingInlinedBlock", _wrap_SBBlock_GetContainingInlinedBlock},
{ "GetSibling", _wrap_SBBlock_GetSibling},
{ "GetFirstChild", _wrap_SBBlock_GetFirstChild},
{ "GetNumRanges", _wrap_SBBlock_GetNumRanges},
{ "GetRangeStartAddress", _wrap_SBBlock_GetRangeStartAddress},
{ "GetRangeEndAddress", _wrap_SBBlock_GetRangeEndAddress},
{ "GetRangeIndexForBlockAddress", _wrap_SBBlock_GetRangeIndexForBlockAddress},
{ "GetDescription", _wrap_SBBlock_GetDescription},
{ "GetVariables", _wrap_SBBlock_GetVariables},
{ "__tostring", _wrap_SBBlock___tostring},
{0,0}
};
static swig_lua_method swig_SBBlock_meta[] = {
{ "__tostring", _wrap_SBBlock___tostring},
{0,0}
};
static swig_lua_attribute swig_SBBlock_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBBlock_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBBlock_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBBlock_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBBlock_Sf_SwigStatic = {
"SBBlock",
swig_SBBlock_Sf_SwigStatic_methods,
swig_SBBlock_Sf_SwigStatic_attributes,
swig_SBBlock_Sf_SwigStatic_constants,
swig_SBBlock_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBBlock_bases[] = {0};
static const char *swig_SBBlock_base_names[] = {0};
static swig_lua_class _wrap_class_SBBlock = { "SBBlock", "SBBlock", &SWIGTYPE_p_lldb__SBBlock,_proxy__wrap_new_SBBlock, swig_delete_SBBlock, swig_SBBlock_methods, swig_SBBlock_attributes, &swig_SBBlock_Sf_SwigStatic, swig_SBBlock_meta, swig_SBBlock_bases, swig_SBBlock_base_names };
static int _wrap_new_SBBreakpoint__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpoint::SBBreakpoint",0,0)
result = (lldb::SBBreakpoint *)new lldb::SBBreakpoint();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBBreakpoint__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = 0 ;
lldb::SBBreakpoint *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpoint::SBBreakpoint",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SBBreakpoint",1,"lldb::SBBreakpoint const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("new_SBBreakpoint",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = (lldb::SBBreakpoint *)new lldb::SBBreakpoint((lldb::SBBreakpoint const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBBreakpoint(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBBreakpoint__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBBreakpoint__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBBreakpoint'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBBreakpoint::SBBreakpoint()\n"
" lldb::SBBreakpoint::SBBreakpoint(lldb::SBBreakpoint const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBBreakpoint___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
lldb::SBBreakpoint *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpoint::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::operator ==",1,"lldb::SBBreakpoint *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::operator ==",2,"lldb::SBBreakpoint const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint___eq",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint___eq",2,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = (bool)(arg1)->operator ==((lldb::SBBreakpoint const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
lldb::break_id_t result;
SWIG_check_num_args("lldb::SBBreakpoint::GetID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetID",1,"lldb::SBBreakpoint const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_GetID",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = (lldb::break_id_t)((lldb::SBBreakpoint const *)arg1)->GetID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpoint::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::IsValid",1,"lldb::SBBreakpoint const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_IsValid",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = (bool)((lldb::SBBreakpoint const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_ClearAllBreakpointSites(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
SWIG_check_num_args("lldb::SBBreakpoint::ClearAllBreakpointSites",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::ClearAllBreakpointSites",1,"lldb::SBBreakpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_ClearAllBreakpointSites",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
(arg1)->ClearAllBreakpointSites();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetTarget(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
lldb::SBTarget result;
SWIG_check_num_args("lldb::SBBreakpoint::GetTarget",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetTarget",1,"lldb::SBBreakpoint const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_GetTarget",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = ((lldb::SBBreakpoint const *)arg1)->GetTarget();
{
lldb::SBTarget * resultptr = new lldb::SBTarget((const lldb::SBTarget &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_FindLocationByAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
lldb::addr_t arg2 ;
lldb::SBBreakpointLocation result;
SWIG_check_num_args("lldb::SBBreakpoint::FindLocationByAddress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::FindLocationByAddress",1,"lldb::SBBreakpoint *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::FindLocationByAddress",2,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_FindLocationByAddress",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
result = (arg1)->FindLocationByAddress(arg2);
{
lldb::SBBreakpointLocation * resultptr = new lldb::SBBreakpointLocation((const lldb::SBBreakpointLocation &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpointLocation,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_FindLocationIDByAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
lldb::addr_t arg2 ;
lldb::break_id_t result;
SWIG_check_num_args("lldb::SBBreakpoint::FindLocationIDByAddress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::FindLocationIDByAddress",1,"lldb::SBBreakpoint *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::FindLocationIDByAddress",2,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_FindLocationIDByAddress",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
result = (lldb::break_id_t)(arg1)->FindLocationIDByAddress(arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_FindLocationByID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
lldb::break_id_t arg2 ;
lldb::SBBreakpointLocation result;
SWIG_check_num_args("lldb::SBBreakpoint::FindLocationByID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::FindLocationByID",1,"lldb::SBBreakpoint *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::FindLocationByID",2,"lldb::break_id_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_FindLocationByID",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (lldb::break_id_t)lua_tointeger(L, 2);
result = (arg1)->FindLocationByID(arg2);
{
lldb::SBBreakpointLocation * resultptr = new lldb::SBBreakpointLocation((const lldb::SBBreakpointLocation &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpointLocation,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetLocationAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
uint32_t arg2 ;
lldb::SBBreakpointLocation result;
SWIG_check_num_args("lldb::SBBreakpoint::GetLocationAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetLocationAtIndex",1,"lldb::SBBreakpoint *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::GetLocationAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_GetLocationAtIndex",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetLocationAtIndex(arg2);
{
lldb::SBBreakpointLocation * resultptr = new lldb::SBBreakpointLocation((const lldb::SBBreakpointLocation &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpointLocation,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_SetEnabled(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBBreakpoint::SetEnabled",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetEnabled",1,"lldb::SBBreakpoint *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetEnabled",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_SetEnabled",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetEnabled(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_IsEnabled(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpoint::IsEnabled",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::IsEnabled",1,"lldb::SBBreakpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_IsEnabled",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = (bool)(arg1)->IsEnabled();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_SetOneShot(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBBreakpoint::SetOneShot",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetOneShot",1,"lldb::SBBreakpoint *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetOneShot",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_SetOneShot",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetOneShot(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_IsOneShot(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpoint::IsOneShot",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::IsOneShot",1,"lldb::SBBreakpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_IsOneShot",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = (bool)(arg1)->IsOneShot();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_IsInternal(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpoint::IsInternal",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::IsInternal",1,"lldb::SBBreakpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_IsInternal",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = (bool)(arg1)->IsInternal();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetHitCount(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBBreakpoint::GetHitCount",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetHitCount",1,"lldb::SBBreakpoint const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_GetHitCount",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = (uint32_t)((lldb::SBBreakpoint const *)arg1)->GetHitCount();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_SetIgnoreCount(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBBreakpoint::SetIgnoreCount",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetIgnoreCount",1,"lldb::SBBreakpoint *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetIgnoreCount",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_SetIgnoreCount",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetIgnoreCount(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetIgnoreCount(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBBreakpoint::GetIgnoreCount",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetIgnoreCount",1,"lldb::SBBreakpoint const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_GetIgnoreCount",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = (uint32_t)((lldb::SBBreakpoint const *)arg1)->GetIgnoreCount();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_SetCondition(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBBreakpoint::SetCondition",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetCondition",1,"lldb::SBBreakpoint *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetCondition",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_SetCondition",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetCondition((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetCondition(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpoint::GetCondition",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetCondition",1,"lldb::SBBreakpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_GetCondition",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = (char *)(arg1)->GetCondition();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_SetAutoContinue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBBreakpoint::SetAutoContinue",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetAutoContinue",1,"lldb::SBBreakpoint *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetAutoContinue",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_SetAutoContinue",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetAutoContinue(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetAutoContinue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpoint::GetAutoContinue",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetAutoContinue",1,"lldb::SBBreakpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_GetAutoContinue",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = (bool)(arg1)->GetAutoContinue();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_SetThreadID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
lldb::tid_t arg2 ;
SWIG_check_num_args("lldb::SBBreakpoint::SetThreadID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetThreadID",1,"lldb::SBBreakpoint *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetThreadID",2,"lldb::tid_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_SetThreadID",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (lldb::tid_t)lua_tointeger(L, 2);
(arg1)->SetThreadID(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetThreadID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
lldb::tid_t result;
SWIG_check_num_args("lldb::SBBreakpoint::GetThreadID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetThreadID",1,"lldb::SBBreakpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_GetThreadID",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = (lldb::tid_t)(arg1)->GetThreadID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_SetThreadIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBBreakpoint::SetThreadIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetThreadIndex",1,"lldb::SBBreakpoint *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetThreadIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_SetThreadIndex",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetThreadIndex(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetThreadIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBBreakpoint::GetThreadIndex",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetThreadIndex",1,"lldb::SBBreakpoint const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_GetThreadIndex",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = (uint32_t)((lldb::SBBreakpoint const *)arg1)->GetThreadIndex();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_SetThreadName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBBreakpoint::SetThreadName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetThreadName",1,"lldb::SBBreakpoint *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetThreadName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_SetThreadName",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetThreadName((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetThreadName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpoint::GetThreadName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetThreadName",1,"lldb::SBBreakpoint const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_GetThreadName",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = (char *)((lldb::SBBreakpoint const *)arg1)->GetThreadName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_SetQueueName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBBreakpoint::SetQueueName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetQueueName",1,"lldb::SBBreakpoint *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetQueueName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_SetQueueName",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetQueueName((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetQueueName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpoint::GetQueueName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetQueueName",1,"lldb::SBBreakpoint const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_GetQueueName",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = (char *)((lldb::SBBreakpoint const *)arg1)->GetQueueName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_SetScriptCallbackFunction__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBBreakpoint::SetScriptCallbackFunction",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetScriptCallbackFunction",1,"lldb::SBBreakpoint *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetScriptCallbackFunction",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_SetScriptCallbackFunction",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetScriptCallbackFunction((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_SetScriptCallbackFunction__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBStructuredData *arg3 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBBreakpoint::SetScriptCallbackFunction",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetScriptCallbackFunction",1,"lldb::SBBreakpoint *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetScriptCallbackFunction",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBBreakpoint::SetScriptCallbackFunction",3,"lldb::SBStructuredData &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_SetScriptCallbackFunction",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBBreakpoint_SetScriptCallbackFunction",3,SWIGTYPE_p_lldb__SBStructuredData);
}
result = (arg1)->SetScriptCallbackFunction((char const *)arg2,*arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_SetScriptCallbackFunction(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpoint, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBBreakpoint_SetScriptCallbackFunction__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpoint, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBBreakpoint_SetScriptCallbackFunction__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBBreakpoint_SetScriptCallbackFunction'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBBreakpoint::SetScriptCallbackFunction(char const *)\n"
" lldb::SBBreakpoint::SetScriptCallbackFunction(char const *,lldb::SBStructuredData &)\n");
lua_error(L);return 0;
}
static int _wrap_SBBreakpoint_SetScriptCallbackBody(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBBreakpoint::SetScriptCallbackBody",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetScriptCallbackBody",1,"lldb::SBBreakpoint *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetScriptCallbackBody",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_SetScriptCallbackBody",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->SetScriptCallbackBody((char const *)arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_SetCommandLineCommands(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
lldb::SBStringList *arg2 = 0 ;
SWIG_check_num_args("lldb::SBBreakpoint::SetCommandLineCommands",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetCommandLineCommands",1,"lldb::SBBreakpoint *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetCommandLineCommands",2,"lldb::SBStringList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_SetCommandLineCommands",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBBreakpoint_SetCommandLineCommands",2,SWIGTYPE_p_lldb__SBStringList);
}
(arg1)->SetCommandLineCommands(*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetCommandLineCommands(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
lldb::SBStringList *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpoint::GetCommandLineCommands",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetCommandLineCommands",1,"lldb::SBBreakpoint *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::GetCommandLineCommands",2,"lldb::SBStringList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_GetCommandLineCommands",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBBreakpoint_GetCommandLineCommands",2,SWIGTYPE_p_lldb__SBStringList);
}
result = (bool)(arg1)->GetCommandLineCommands(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_AddName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
char *arg2 = (char *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpoint::AddName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::AddName",1,"lldb::SBBreakpoint *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::AddName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_AddName",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (char *)lua_tostring(L, 2);
result = (bool)(arg1)->AddName((char const *)arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_AddNameWithErrorHandling(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBBreakpoint::AddNameWithErrorHandling",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::AddNameWithErrorHandling",1,"lldb::SBBreakpoint *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::AddNameWithErrorHandling",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_AddNameWithErrorHandling",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->AddNameWithErrorHandling((char const *)arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_RemoveName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBBreakpoint::RemoveName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::RemoveName",1,"lldb::SBBreakpoint *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::RemoveName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_RemoveName",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->RemoveName((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_MatchesName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
char *arg2 = (char *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpoint::MatchesName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::MatchesName",1,"lldb::SBBreakpoint *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::MatchesName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_MatchesName",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (char *)lua_tostring(L, 2);
result = (bool)(arg1)->MatchesName((char const *)arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetNames(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
lldb::SBStringList *arg2 = 0 ;
SWIG_check_num_args("lldb::SBBreakpoint::GetNames",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetNames",1,"lldb::SBBreakpoint *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::GetNames",2,"lldb::SBStringList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_GetNames",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBBreakpoint_GetNames",2,SWIGTYPE_p_lldb__SBStringList);
}
(arg1)->GetNames(*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetNumResolvedLocations(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBBreakpoint::GetNumResolvedLocations",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetNumResolvedLocations",1,"lldb::SBBreakpoint const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_GetNumResolvedLocations",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = ((lldb::SBBreakpoint const *)arg1)->GetNumResolvedLocations();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetNumLocations(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBBreakpoint::GetNumLocations",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetNumLocations",1,"lldb::SBBreakpoint const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_GetNumLocations",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = ((lldb::SBBreakpoint const *)arg1)->GetNumLocations();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetDescription__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpoint::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetDescription",1,"lldb::SBBreakpoint *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_GetDescription",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBBreakpoint_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetDescription__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool arg3 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpoint::GetDescription",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetDescription",1,"lldb::SBBreakpoint *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::GetDescription",2,"lldb::SBStream &");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBBreakpoint::GetDescription",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_GetDescription",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBBreakpoint_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
arg3 = (lua_toboolean(L, 3)!=0);
result = (bool)(arg1)->GetDescription(*arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetDescription(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpoint, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBBreakpoint_GetDescription__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpoint, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[2]);
}
if (_v) {
return _wrap_SBBreakpoint_GetDescription__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBBreakpoint_GetDescription'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBBreakpoint::GetDescription(lldb::SBStream &)\n"
" lldb::SBBreakpoint::GetDescription(lldb::SBStream &,bool)\n");
lua_error(L);return 0;
}
static int _wrap_SBBreakpoint_AddLocation(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
lldb::SBAddress *arg2 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBBreakpoint::AddLocation",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::AddLocation",1,"lldb::SBBreakpoint *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::AddLocation",2,"lldb::SBAddress &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_AddLocation",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBBreakpoint_AddLocation",2,SWIGTYPE_p_lldb__SBAddress);
}
result = (arg1)->AddLocation(*arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_SerializeToStructuredData(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
lldb::SBStructuredData result;
SWIG_check_num_args("lldb::SBBreakpoint::SerializeToStructuredData",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SerializeToStructuredData",1,"lldb::SBBreakpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_SerializeToStructuredData",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = (arg1)->SerializeToStructuredData();
{
lldb::SBStructuredData * resultptr = new lldb::SBStructuredData((const lldb::SBStructuredData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_EventIsBreakpointEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpoint::EventIsBreakpointEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::EventIsBreakpointEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBBreakpoint_EventIsBreakpointEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)lldb::SBBreakpoint::EventIsBreakpointEvent((lldb::SBEvent const &)*arg1);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetBreakpointEventTypeFromEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
lldb::BreakpointEventType result;
SWIG_check_num_args("lldb::SBBreakpoint::GetBreakpointEventTypeFromEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetBreakpointEventTypeFromEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBBreakpoint_GetBreakpointEventTypeFromEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (lldb::BreakpointEventType)lldb::SBBreakpoint::GetBreakpointEventTypeFromEvent((lldb::SBEvent const &)*arg1);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetBreakpointFromEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBBreakpoint::GetBreakpointFromEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetBreakpointFromEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBBreakpoint_GetBreakpointFromEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = lldb::SBBreakpoint::GetBreakpointFromEvent((lldb::SBEvent const &)*arg1);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetBreakpointLocationAtIndexFromEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
uint32_t arg2 ;
lldb::SBBreakpointLocation result;
SWIG_check_num_args("lldb::SBBreakpoint::GetBreakpointLocationAtIndexFromEvent",2,2)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetBreakpointLocationAtIndexFromEvent",1,"lldb::SBEvent const &");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::GetBreakpointLocationAtIndexFromEvent",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBBreakpoint_GetBreakpointLocationAtIndexFromEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = lldb::SBBreakpoint::GetBreakpointLocationAtIndexFromEvent((lldb::SBEvent const &)*arg1,arg2);
{
lldb::SBBreakpointLocation * resultptr = new lldb::SBBreakpointLocation((const lldb::SBBreakpointLocation &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpointLocation,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_GetNumBreakpointLocationsFromEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBBreakpoint::GetNumBreakpointLocationsFromEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetNumBreakpointLocationsFromEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBBreakpoint_GetNumBreakpointLocationsFromEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (uint32_t)lldb::SBBreakpoint::GetNumBreakpointLocationsFromEvent((lldb::SBEvent const &)*arg1);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint_IsHardware(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpoint::IsHardware",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::IsHardware",1,"lldb::SBBreakpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint_IsHardware",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = (bool)(arg1)->IsHardware();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpoint___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBBreakpoint::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::__str__",1,"lldb::SBBreakpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpoint___tostring",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = lldb_SBBreakpoint___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBBreakpoint(void *obj) {
lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBBreakpoint(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBBreakpoint);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBBreakpoint_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBBreakpoint_methods[]= {
{ "__eq", _wrap_SBBreakpoint___eq},
{ "GetID", _wrap_SBBreakpoint_GetID},
{ "IsValid", _wrap_SBBreakpoint_IsValid},
{ "ClearAllBreakpointSites", _wrap_SBBreakpoint_ClearAllBreakpointSites},
{ "GetTarget", _wrap_SBBreakpoint_GetTarget},
{ "FindLocationByAddress", _wrap_SBBreakpoint_FindLocationByAddress},
{ "FindLocationIDByAddress", _wrap_SBBreakpoint_FindLocationIDByAddress},
{ "FindLocationByID", _wrap_SBBreakpoint_FindLocationByID},
{ "GetLocationAtIndex", _wrap_SBBreakpoint_GetLocationAtIndex},
{ "SetEnabled", _wrap_SBBreakpoint_SetEnabled},
{ "IsEnabled", _wrap_SBBreakpoint_IsEnabled},
{ "SetOneShot", _wrap_SBBreakpoint_SetOneShot},
{ "IsOneShot", _wrap_SBBreakpoint_IsOneShot},
{ "IsInternal", _wrap_SBBreakpoint_IsInternal},
{ "GetHitCount", _wrap_SBBreakpoint_GetHitCount},
{ "SetIgnoreCount", _wrap_SBBreakpoint_SetIgnoreCount},
{ "GetIgnoreCount", _wrap_SBBreakpoint_GetIgnoreCount},
{ "SetCondition", _wrap_SBBreakpoint_SetCondition},
{ "GetCondition", _wrap_SBBreakpoint_GetCondition},
{ "SetAutoContinue", _wrap_SBBreakpoint_SetAutoContinue},
{ "GetAutoContinue", _wrap_SBBreakpoint_GetAutoContinue},
{ "SetThreadID", _wrap_SBBreakpoint_SetThreadID},
{ "GetThreadID", _wrap_SBBreakpoint_GetThreadID},
{ "SetThreadIndex", _wrap_SBBreakpoint_SetThreadIndex},
{ "GetThreadIndex", _wrap_SBBreakpoint_GetThreadIndex},
{ "SetThreadName", _wrap_SBBreakpoint_SetThreadName},
{ "GetThreadName", _wrap_SBBreakpoint_GetThreadName},
{ "SetQueueName", _wrap_SBBreakpoint_SetQueueName},
{ "GetQueueName", _wrap_SBBreakpoint_GetQueueName},
{ "SetScriptCallbackFunction", _wrap_SBBreakpoint_SetScriptCallbackFunction},
{ "SetScriptCallbackBody", _wrap_SBBreakpoint_SetScriptCallbackBody},
{ "SetCommandLineCommands", _wrap_SBBreakpoint_SetCommandLineCommands},
{ "GetCommandLineCommands", _wrap_SBBreakpoint_GetCommandLineCommands},
{ "AddName", _wrap_SBBreakpoint_AddName},
{ "AddNameWithErrorHandling", _wrap_SBBreakpoint_AddNameWithErrorHandling},
{ "RemoveName", _wrap_SBBreakpoint_RemoveName},
{ "MatchesName", _wrap_SBBreakpoint_MatchesName},
{ "GetNames", _wrap_SBBreakpoint_GetNames},
{ "GetNumResolvedLocations", _wrap_SBBreakpoint_GetNumResolvedLocations},
{ "GetNumLocations", _wrap_SBBreakpoint_GetNumLocations},
{ "GetDescription", _wrap_SBBreakpoint_GetDescription},
{ "AddLocation", _wrap_SBBreakpoint_AddLocation},
{ "SerializeToStructuredData", _wrap_SBBreakpoint_SerializeToStructuredData},
{ "IsHardware", _wrap_SBBreakpoint_IsHardware},
{ "__tostring", _wrap_SBBreakpoint___tostring},
{0,0}
};
static swig_lua_method swig_SBBreakpoint_meta[] = {
{ "__eq", _wrap_SBBreakpoint___eq},
{ "__tostring", _wrap_SBBreakpoint___tostring},
{0,0}
};
static swig_lua_attribute swig_SBBreakpoint_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBBreakpoint_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBBreakpoint_Sf_SwigStatic_methods[]= {
{ "EventIsBreakpointEvent", _wrap_SBBreakpoint_EventIsBreakpointEvent},
{ "GetBreakpointEventTypeFromEvent", _wrap_SBBreakpoint_GetBreakpointEventTypeFromEvent},
{ "GetBreakpointFromEvent", _wrap_SBBreakpoint_GetBreakpointFromEvent},
{ "GetBreakpointLocationAtIndexFromEvent", _wrap_SBBreakpoint_GetBreakpointLocationAtIndexFromEvent},
{ "GetNumBreakpointLocationsFromEvent", _wrap_SBBreakpoint_GetNumBreakpointLocationsFromEvent},
{0,0}
};
static swig_lua_class* swig_SBBreakpoint_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBBreakpoint_Sf_SwigStatic = {
"SBBreakpoint",
swig_SBBreakpoint_Sf_SwigStatic_methods,
swig_SBBreakpoint_Sf_SwigStatic_attributes,
swig_SBBreakpoint_Sf_SwigStatic_constants,
swig_SBBreakpoint_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBBreakpoint_bases[] = {0};
static const char *swig_SBBreakpoint_base_names[] = {0};
static swig_lua_class _wrap_class_SBBreakpoint = { "SBBreakpoint", "SBBreakpoint", &SWIGTYPE_p_lldb__SBBreakpoint,_proxy__wrap_new_SBBreakpoint, swig_delete_SBBreakpoint, swig_SBBreakpoint_methods, swig_SBBreakpoint_attributes, &swig_SBBreakpoint_Sf_SwigStatic, swig_SBBreakpoint_meta, swig_SBBreakpoint_bases, swig_SBBreakpoint_base_names };
static int _wrap_new_SBBreakpointList(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = 0 ;
lldb::SBBreakpointList *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpointList::SBBreakpointList",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpointList::SBBreakpointList",1,"lldb::SBTarget &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("new_SBBreakpointList",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (lldb::SBBreakpointList *)new lldb::SBBreakpointList(*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBreakpointList,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointList_GetSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBBreakpointList::GetSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointList::GetSize",1,"lldb::SBBreakpointList const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointList,0))){
SWIG_fail_ptr("SBBreakpointList_GetSize",1,SWIGTYPE_p_lldb__SBBreakpointList);
}
result = ((lldb::SBBreakpointList const *)arg1)->GetSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointList_GetBreakpointAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
size_t arg2 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBBreakpointList::GetBreakpointAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointList::GetBreakpointAtIndex",1,"lldb::SBBreakpointList *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpointList::GetBreakpointAtIndex",2,"size_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointList,0))){
SWIG_fail_ptr("SBBreakpointList_GetBreakpointAtIndex",1,SWIGTYPE_p_lldb__SBBreakpointList);
}
arg2 = (size_t)lua_tointeger(L, 2);
result = (arg1)->GetBreakpointAtIndex(arg2);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointList_FindBreakpointByID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
lldb::break_id_t arg2 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBBreakpointList::FindBreakpointByID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointList::FindBreakpointByID",1,"lldb::SBBreakpointList *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpointList::FindBreakpointByID",2,"lldb::break_id_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointList,0))){
SWIG_fail_ptr("SBBreakpointList_FindBreakpointByID",1,SWIGTYPE_p_lldb__SBBreakpointList);
}
arg2 = (lldb::break_id_t)lua_tointeger(L, 2);
result = (arg1)->FindBreakpointByID(arg2);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointList_Append(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
lldb::SBBreakpoint *arg2 = 0 ;
SWIG_check_num_args("lldb::SBBreakpointList::Append",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointList::Append",1,"lldb::SBBreakpointList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpointList::Append",2,"lldb::SBBreakpoint const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointList,0))){
SWIG_fail_ptr("SBBreakpointList_Append",1,SWIGTYPE_p_lldb__SBBreakpointList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpointList_Append",2,SWIGTYPE_p_lldb__SBBreakpoint);
}
(arg1)->Append((lldb::SBBreakpoint const &)*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointList_AppendIfUnique(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
lldb::SBBreakpoint *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpointList::AppendIfUnique",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointList::AppendIfUnique",1,"lldb::SBBreakpointList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpointList::AppendIfUnique",2,"lldb::SBBreakpoint const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointList,0))){
SWIG_fail_ptr("SBBreakpointList_AppendIfUnique",1,SWIGTYPE_p_lldb__SBBreakpointList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("SBBreakpointList_AppendIfUnique",2,SWIGTYPE_p_lldb__SBBreakpoint);
}
result = (bool)(arg1)->AppendIfUnique((lldb::SBBreakpoint const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointList_AppendByID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
lldb::break_id_t arg2 ;
SWIG_check_num_args("lldb::SBBreakpointList::AppendByID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointList::AppendByID",1,"lldb::SBBreakpointList *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpointList::AppendByID",2,"lldb::break_id_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointList,0))){
SWIG_fail_ptr("SBBreakpointList_AppendByID",1,SWIGTYPE_p_lldb__SBBreakpointList);
}
arg2 = (lldb::break_id_t)lua_tointeger(L, 2);
(arg1)->AppendByID(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointList_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
SWIG_check_num_args("lldb::SBBreakpointList::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointList::Clear",1,"lldb::SBBreakpointList *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointList,0))){
SWIG_fail_ptr("SBBreakpointList_Clear",1,SWIGTYPE_p_lldb__SBBreakpointList);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBBreakpointList(void *obj) {
lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBBreakpointList(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBBreakpointList);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBBreakpointList_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBBreakpointList_methods[]= {
{ "GetSize", _wrap_SBBreakpointList_GetSize},
{ "GetBreakpointAtIndex", _wrap_SBBreakpointList_GetBreakpointAtIndex},
{ "FindBreakpointByID", _wrap_SBBreakpointList_FindBreakpointByID},
{ "Append", _wrap_SBBreakpointList_Append},
{ "AppendIfUnique", _wrap_SBBreakpointList_AppendIfUnique},
{ "AppendByID", _wrap_SBBreakpointList_AppendByID},
{ "Clear", _wrap_SBBreakpointList_Clear},
{0,0}
};
static swig_lua_method swig_SBBreakpointList_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBBreakpointList_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBBreakpointList_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBBreakpointList_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBBreakpointList_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBBreakpointList_Sf_SwigStatic = {
"SBBreakpointList",
swig_SBBreakpointList_Sf_SwigStatic_methods,
swig_SBBreakpointList_Sf_SwigStatic_attributes,
swig_SBBreakpointList_Sf_SwigStatic_constants,
swig_SBBreakpointList_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBBreakpointList_bases[] = {0};
static const char *swig_SBBreakpointList_base_names[] = {0};
static swig_lua_class _wrap_class_SBBreakpointList = { "SBBreakpointList", "SBBreakpointList", &SWIGTYPE_p_lldb__SBBreakpointList,_proxy__wrap_new_SBBreakpointList, swig_delete_SBBreakpointList, swig_SBBreakpointList_methods, swig_SBBreakpointList_attributes, &swig_SBBreakpointList_Sf_SwigStatic, swig_SBBreakpointList_meta, swig_SBBreakpointList_bases, swig_SBBreakpointList_base_names };
static int _wrap_new_SBBreakpointLocation__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpointLocation::SBBreakpointLocation",0,0)
result = (lldb::SBBreakpointLocation *)new lldb::SBBreakpointLocation();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBreakpointLocation,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBBreakpointLocation__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = 0 ;
lldb::SBBreakpointLocation *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpointLocation::SBBreakpointLocation",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SBBreakpointLocation",1,"lldb::SBBreakpointLocation const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("new_SBBreakpointLocation",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
result = (lldb::SBBreakpointLocation *)new lldb::SBBreakpointLocation((lldb::SBBreakpointLocation const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBreakpointLocation,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBBreakpointLocation(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBBreakpointLocation__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBBreakpointLocation__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBBreakpointLocation'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBBreakpointLocation::SBBreakpointLocation()\n"
" lldb::SBBreakpointLocation::SBBreakpointLocation(lldb::SBBreakpointLocation const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBBreakpointLocation_GetID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
lldb::break_id_t result;
SWIG_check_num_args("lldb::SBBreakpointLocation::GetID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetID",1,"lldb::SBBreakpointLocation *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_GetID",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
result = (lldb::break_id_t)(arg1)->GetID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpointLocation::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::IsValid",1,"lldb::SBBreakpointLocation const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_IsValid",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
result = (bool)((lldb::SBBreakpointLocation const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_GetAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBBreakpointLocation::GetAddress",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetAddress",1,"lldb::SBBreakpointLocation *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_GetAddress",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
result = (arg1)->GetAddress();
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_GetLoadAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBBreakpointLocation::GetLoadAddress",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetLoadAddress",1,"lldb::SBBreakpointLocation *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_GetLoadAddress",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
result = (lldb::addr_t)(arg1)->GetLoadAddress();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_SetEnabled(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBBreakpointLocation::SetEnabled",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetEnabled",1,"lldb::SBBreakpointLocation *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetEnabled",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_SetEnabled",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetEnabled(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_IsEnabled(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpointLocation::IsEnabled",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::IsEnabled",1,"lldb::SBBreakpointLocation *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_IsEnabled",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
result = (bool)(arg1)->IsEnabled();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_GetHitCount(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBBreakpointLocation::GetHitCount",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetHitCount",1,"lldb::SBBreakpointLocation *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_GetHitCount",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
result = (uint32_t)(arg1)->GetHitCount();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_GetIgnoreCount(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBBreakpointLocation::GetIgnoreCount",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetIgnoreCount",1,"lldb::SBBreakpointLocation *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_GetIgnoreCount",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
result = (uint32_t)(arg1)->GetIgnoreCount();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_SetIgnoreCount(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBBreakpointLocation::SetIgnoreCount",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetIgnoreCount",1,"lldb::SBBreakpointLocation *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetIgnoreCount",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_SetIgnoreCount",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetIgnoreCount(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_SetCondition(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBBreakpointLocation::SetCondition",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetCondition",1,"lldb::SBBreakpointLocation *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetCondition",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_SetCondition",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetCondition((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_GetCondition(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpointLocation::GetCondition",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetCondition",1,"lldb::SBBreakpointLocation *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_GetCondition",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
result = (char *)(arg1)->GetCondition();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_GetAutoContinue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpointLocation::GetAutoContinue",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetAutoContinue",1,"lldb::SBBreakpointLocation *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_GetAutoContinue",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
result = (bool)(arg1)->GetAutoContinue();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_SetAutoContinue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBBreakpointLocation::SetAutoContinue",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetAutoContinue",1,"lldb::SBBreakpointLocation *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetAutoContinue",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_SetAutoContinue",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetAutoContinue(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_SetScriptCallbackFunction__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBBreakpointLocation::SetScriptCallbackFunction",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetScriptCallbackFunction",1,"lldb::SBBreakpointLocation *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetScriptCallbackFunction",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_SetScriptCallbackFunction",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetScriptCallbackFunction((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_SetScriptCallbackFunction__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBStructuredData *arg3 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBBreakpointLocation::SetScriptCallbackFunction",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetScriptCallbackFunction",1,"lldb::SBBreakpointLocation *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetScriptCallbackFunction",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetScriptCallbackFunction",3,"lldb::SBStructuredData &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_SetScriptCallbackFunction",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBBreakpointLocation_SetScriptCallbackFunction",3,SWIGTYPE_p_lldb__SBStructuredData);
}
result = (arg1)->SetScriptCallbackFunction((char const *)arg2,*arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_SetScriptCallbackFunction(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointLocation, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBBreakpointLocation_SetScriptCallbackFunction__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointLocation, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBBreakpointLocation_SetScriptCallbackFunction__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBBreakpointLocation_SetScriptCallbackFunction'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBBreakpointLocation::SetScriptCallbackFunction(char const *)\n"
" lldb::SBBreakpointLocation::SetScriptCallbackFunction(char const *,lldb::SBStructuredData &)\n");
lua_error(L);return 0;
}
static int _wrap_SBBreakpointLocation_SetScriptCallbackBody(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBBreakpointLocation::SetScriptCallbackBody",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetScriptCallbackBody",1,"lldb::SBBreakpointLocation *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetScriptCallbackBody",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_SetScriptCallbackBody",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->SetScriptCallbackBody((char const *)arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_SetCommandLineCommands(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
lldb::SBStringList *arg2 = 0 ;
SWIG_check_num_args("lldb::SBBreakpointLocation::SetCommandLineCommands",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetCommandLineCommands",1,"lldb::SBBreakpointLocation *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetCommandLineCommands",2,"lldb::SBStringList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_SetCommandLineCommands",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBBreakpointLocation_SetCommandLineCommands",2,SWIGTYPE_p_lldb__SBStringList);
}
(arg1)->SetCommandLineCommands(*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_GetCommandLineCommands(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
lldb::SBStringList *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpointLocation::GetCommandLineCommands",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetCommandLineCommands",1,"lldb::SBBreakpointLocation *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetCommandLineCommands",2,"lldb::SBStringList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_GetCommandLineCommands",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBBreakpointLocation_GetCommandLineCommands",2,SWIGTYPE_p_lldb__SBStringList);
}
result = (bool)(arg1)->GetCommandLineCommands(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_SetThreadID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
lldb::tid_t arg2 ;
SWIG_check_num_args("lldb::SBBreakpointLocation::SetThreadID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetThreadID",1,"lldb::SBBreakpointLocation *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetThreadID",2,"lldb::tid_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_SetThreadID",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
arg2 = (lldb::tid_t)lua_tointeger(L, 2);
(arg1)->SetThreadID(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_GetThreadID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
lldb::tid_t result;
SWIG_check_num_args("lldb::SBBreakpointLocation::GetThreadID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetThreadID",1,"lldb::SBBreakpointLocation *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_GetThreadID",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
result = (lldb::tid_t)(arg1)->GetThreadID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_SetThreadIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBBreakpointLocation::SetThreadIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetThreadIndex",1,"lldb::SBBreakpointLocation *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetThreadIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_SetThreadIndex",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetThreadIndex(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_GetThreadIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBBreakpointLocation::GetThreadIndex",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetThreadIndex",1,"lldb::SBBreakpointLocation const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_GetThreadIndex",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
result = (uint32_t)((lldb::SBBreakpointLocation const *)arg1)->GetThreadIndex();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_SetThreadName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBBreakpointLocation::SetThreadName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetThreadName",1,"lldb::SBBreakpointLocation *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetThreadName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_SetThreadName",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetThreadName((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_GetThreadName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpointLocation::GetThreadName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetThreadName",1,"lldb::SBBreakpointLocation const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_GetThreadName",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
result = (char *)((lldb::SBBreakpointLocation const *)arg1)->GetThreadName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_SetQueueName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBBreakpointLocation::SetQueueName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetQueueName",1,"lldb::SBBreakpointLocation *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetQueueName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_SetQueueName",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetQueueName((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_GetQueueName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpointLocation::GetQueueName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetQueueName",1,"lldb::SBBreakpointLocation const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_GetQueueName",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
result = (char *)((lldb::SBBreakpointLocation const *)arg1)->GetQueueName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_IsResolved(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpointLocation::IsResolved",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::IsResolved",1,"lldb::SBBreakpointLocation *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_IsResolved",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
result = (bool)(arg1)->IsResolved();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
lldb::SBStream *arg2 = 0 ;
lldb::DescriptionLevel arg3 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpointLocation::GetDescription",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetDescription",1,"lldb::SBBreakpointLocation *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetDescription",2,"lldb::SBStream &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetDescription",3,"lldb::DescriptionLevel");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_GetDescription",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBBreakpointLocation_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3);
result = (bool)(arg1)->GetDescription(*arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation_GetBreakpoint(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBBreakpointLocation::GetBreakpoint",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetBreakpoint",1,"lldb::SBBreakpointLocation *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation_GetBreakpoint",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
result = (arg1)->GetBreakpoint();
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointLocation___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBBreakpointLocation::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::__str__",1,"lldb::SBBreakpointLocation *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){
SWIG_fail_ptr("SBBreakpointLocation___tostring",1,SWIGTYPE_p_lldb__SBBreakpointLocation);
}
result = lldb_SBBreakpointLocation___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBBreakpointLocation(void *obj) {
lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBBreakpointLocation(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBBreakpointLocation);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBBreakpointLocation_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBBreakpointLocation_methods[]= {
{ "GetID", _wrap_SBBreakpointLocation_GetID},
{ "IsValid", _wrap_SBBreakpointLocation_IsValid},
{ "GetAddress", _wrap_SBBreakpointLocation_GetAddress},
{ "GetLoadAddress", _wrap_SBBreakpointLocation_GetLoadAddress},
{ "SetEnabled", _wrap_SBBreakpointLocation_SetEnabled},
{ "IsEnabled", _wrap_SBBreakpointLocation_IsEnabled},
{ "GetHitCount", _wrap_SBBreakpointLocation_GetHitCount},
{ "GetIgnoreCount", _wrap_SBBreakpointLocation_GetIgnoreCount},
{ "SetIgnoreCount", _wrap_SBBreakpointLocation_SetIgnoreCount},
{ "SetCondition", _wrap_SBBreakpointLocation_SetCondition},
{ "GetCondition", _wrap_SBBreakpointLocation_GetCondition},
{ "GetAutoContinue", _wrap_SBBreakpointLocation_GetAutoContinue},
{ "SetAutoContinue", _wrap_SBBreakpointLocation_SetAutoContinue},
{ "SetScriptCallbackFunction", _wrap_SBBreakpointLocation_SetScriptCallbackFunction},
{ "SetScriptCallbackBody", _wrap_SBBreakpointLocation_SetScriptCallbackBody},
{ "SetCommandLineCommands", _wrap_SBBreakpointLocation_SetCommandLineCommands},
{ "GetCommandLineCommands", _wrap_SBBreakpointLocation_GetCommandLineCommands},
{ "SetThreadID", _wrap_SBBreakpointLocation_SetThreadID},
{ "GetThreadID", _wrap_SBBreakpointLocation_GetThreadID},
{ "SetThreadIndex", _wrap_SBBreakpointLocation_SetThreadIndex},
{ "GetThreadIndex", _wrap_SBBreakpointLocation_GetThreadIndex},
{ "SetThreadName", _wrap_SBBreakpointLocation_SetThreadName},
{ "GetThreadName", _wrap_SBBreakpointLocation_GetThreadName},
{ "SetQueueName", _wrap_SBBreakpointLocation_SetQueueName},
{ "GetQueueName", _wrap_SBBreakpointLocation_GetQueueName},
{ "IsResolved", _wrap_SBBreakpointLocation_IsResolved},
{ "GetDescription", _wrap_SBBreakpointLocation_GetDescription},
{ "GetBreakpoint", _wrap_SBBreakpointLocation_GetBreakpoint},
{ "__tostring", _wrap_SBBreakpointLocation___tostring},
{0,0}
};
static swig_lua_method swig_SBBreakpointLocation_meta[] = {
{ "__tostring", _wrap_SBBreakpointLocation___tostring},
{0,0}
};
static swig_lua_attribute swig_SBBreakpointLocation_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBBreakpointLocation_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBBreakpointLocation_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBBreakpointLocation_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBBreakpointLocation_Sf_SwigStatic = {
"SBBreakpointLocation",
swig_SBBreakpointLocation_Sf_SwigStatic_methods,
swig_SBBreakpointLocation_Sf_SwigStatic_attributes,
swig_SBBreakpointLocation_Sf_SwigStatic_constants,
swig_SBBreakpointLocation_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBBreakpointLocation_bases[] = {0};
static const char *swig_SBBreakpointLocation_base_names[] = {0};
static swig_lua_class _wrap_class_SBBreakpointLocation = { "SBBreakpointLocation", "SBBreakpointLocation", &SWIGTYPE_p_lldb__SBBreakpointLocation,_proxy__wrap_new_SBBreakpointLocation, swig_delete_SBBreakpointLocation, swig_SBBreakpointLocation_methods, swig_SBBreakpointLocation_attributes, &swig_SBBreakpointLocation_Sf_SwigStatic, swig_SBBreakpointLocation_meta, swig_SBBreakpointLocation_bases, swig_SBBreakpointLocation_base_names };
static int _wrap_new_SBBreakpointName__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpointName::SBBreakpointName",0,0)
result = (lldb::SBBreakpointName *)new lldb::SBBreakpointName();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBreakpointName,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBBreakpointName__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = 0 ;
char *arg2 = (char *) 0 ;
lldb::SBBreakpointName *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpointName::SBBreakpointName",2,2)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SBBreakpointName",1,"lldb::SBTarget &");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SBBreakpointName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("new_SBBreakpointName",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
result = (lldb::SBBreakpointName *)new lldb::SBBreakpointName(*arg1,(char const *)arg2);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBreakpointName,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBBreakpointName__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpoint *arg1 = 0 ;
char *arg2 = (char *) 0 ;
lldb::SBBreakpointName *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpointName::SBBreakpointName",2,2)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SBBreakpointName",1,"lldb::SBBreakpoint &");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SBBreakpointName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){
SWIG_fail_ptr("new_SBBreakpointName",1,SWIGTYPE_p_lldb__SBBreakpoint);
}
arg2 = (char *)lua_tostring(L, 2);
result = (lldb::SBBreakpointName *)new lldb::SBBreakpointName(*arg1,(char const *)arg2);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBreakpointName,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBBreakpointName__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = 0 ;
lldb::SBBreakpointName *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpointName::SBBreakpointName",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SBBreakpointName",1,"lldb::SBBreakpointName const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("new_SBBreakpointName",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
result = (lldb::SBBreakpointName *)new lldb::SBBreakpointName((lldb::SBBreakpointName const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBreakpointName,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBBreakpointName(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBBreakpointName__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointName, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBBreakpointName__SWIG_3(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_new_SBBreakpointName__SWIG_2(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_new_SBBreakpointName__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBBreakpointName'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBBreakpointName::SBBreakpointName()\n"
" lldb::SBBreakpointName::SBBreakpointName(lldb::SBTarget &,char const *)\n"
" lldb::SBBreakpointName::SBBreakpointName(lldb::SBBreakpoint &,char const *)\n"
" lldb::SBBreakpointName::SBBreakpointName(lldb::SBBreakpointName const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBBreakpointName___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
lldb::SBBreakpointName *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpointName::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::operator ==",1,"lldb::SBBreakpointName *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::operator ==",2,"lldb::SBBreakpointName const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName___eq",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName___eq",2,SWIGTYPE_p_lldb__SBBreakpointName);
}
result = (bool)(arg1)->operator ==((lldb::SBBreakpointName const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpointName::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::IsValid",1,"lldb::SBBreakpointName const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_IsValid",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
result = (bool)((lldb::SBBreakpointName const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_GetName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpointName::GetName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetName",1,"lldb::SBBreakpointName const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_GetName",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
result = (char *)((lldb::SBBreakpointName const *)arg1)->GetName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_SetEnabled(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBBreakpointName::SetEnabled",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetEnabled",1,"lldb::SBBreakpointName *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetEnabled",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_SetEnabled",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetEnabled(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_IsEnabled(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpointName::IsEnabled",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::IsEnabled",1,"lldb::SBBreakpointName *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_IsEnabled",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
result = (bool)(arg1)->IsEnabled();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_SetOneShot(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBBreakpointName::SetOneShot",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetOneShot",1,"lldb::SBBreakpointName *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetOneShot",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_SetOneShot",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetOneShot(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_IsOneShot(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpointName::IsOneShot",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::IsOneShot",1,"lldb::SBBreakpointName const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_IsOneShot",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
result = (bool)((lldb::SBBreakpointName const *)arg1)->IsOneShot();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_SetIgnoreCount(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBBreakpointName::SetIgnoreCount",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetIgnoreCount",1,"lldb::SBBreakpointName *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetIgnoreCount",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_SetIgnoreCount",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetIgnoreCount(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_GetIgnoreCount(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBBreakpointName::GetIgnoreCount",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetIgnoreCount",1,"lldb::SBBreakpointName const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_GetIgnoreCount",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
result = (uint32_t)((lldb::SBBreakpointName const *)arg1)->GetIgnoreCount();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_SetCondition(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBBreakpointName::SetCondition",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetCondition",1,"lldb::SBBreakpointName *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetCondition",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_SetCondition",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetCondition((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_GetCondition(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpointName::GetCondition",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetCondition",1,"lldb::SBBreakpointName *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_GetCondition",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
result = (char *)(arg1)->GetCondition();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_SetAutoContinue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBBreakpointName::SetAutoContinue",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetAutoContinue",1,"lldb::SBBreakpointName *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetAutoContinue",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_SetAutoContinue",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetAutoContinue(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_GetAutoContinue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpointName::GetAutoContinue",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetAutoContinue",1,"lldb::SBBreakpointName *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_GetAutoContinue",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
result = (bool)(arg1)->GetAutoContinue();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_SetThreadID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
lldb::tid_t arg2 ;
SWIG_check_num_args("lldb::SBBreakpointName::SetThreadID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetThreadID",1,"lldb::SBBreakpointName *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetThreadID",2,"lldb::tid_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_SetThreadID",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
arg2 = (lldb::tid_t)lua_tointeger(L, 2);
(arg1)->SetThreadID(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_GetThreadID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
lldb::tid_t result;
SWIG_check_num_args("lldb::SBBreakpointName::GetThreadID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetThreadID",1,"lldb::SBBreakpointName *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_GetThreadID",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
result = (lldb::tid_t)(arg1)->GetThreadID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_SetThreadIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBBreakpointName::SetThreadIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetThreadIndex",1,"lldb::SBBreakpointName *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetThreadIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_SetThreadIndex",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetThreadIndex(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_GetThreadIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBBreakpointName::GetThreadIndex",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetThreadIndex",1,"lldb::SBBreakpointName const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_GetThreadIndex",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
result = (uint32_t)((lldb::SBBreakpointName const *)arg1)->GetThreadIndex();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_SetThreadName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBBreakpointName::SetThreadName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetThreadName",1,"lldb::SBBreakpointName *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetThreadName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_SetThreadName",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetThreadName((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_GetThreadName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpointName::GetThreadName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetThreadName",1,"lldb::SBBreakpointName const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_GetThreadName",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
result = (char *)((lldb::SBBreakpointName const *)arg1)->GetThreadName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_SetQueueName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBBreakpointName::SetQueueName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetQueueName",1,"lldb::SBBreakpointName *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetQueueName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_SetQueueName",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetQueueName((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_GetQueueName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpointName::GetQueueName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetQueueName",1,"lldb::SBBreakpointName const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_GetQueueName",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
result = (char *)((lldb::SBBreakpointName const *)arg1)->GetQueueName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_SetScriptCallbackFunction__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBBreakpointName::SetScriptCallbackFunction",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetScriptCallbackFunction",1,"lldb::SBBreakpointName *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetScriptCallbackFunction",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_SetScriptCallbackFunction",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetScriptCallbackFunction((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_SetScriptCallbackFunction__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBStructuredData *arg3 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBBreakpointName::SetScriptCallbackFunction",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetScriptCallbackFunction",1,"lldb::SBBreakpointName *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetScriptCallbackFunction",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBBreakpointName::SetScriptCallbackFunction",3,"lldb::SBStructuredData &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_SetScriptCallbackFunction",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBBreakpointName_SetScriptCallbackFunction",3,SWIGTYPE_p_lldb__SBStructuredData);
}
result = (arg1)->SetScriptCallbackFunction((char const *)arg2,*arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_SetScriptCallbackFunction(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointName, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBBreakpointName_SetScriptCallbackFunction__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointName, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBBreakpointName_SetScriptCallbackFunction__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBBreakpointName_SetScriptCallbackFunction'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBBreakpointName::SetScriptCallbackFunction(char const *)\n"
" lldb::SBBreakpointName::SetScriptCallbackFunction(char const *,lldb::SBStructuredData &)\n");
lua_error(L);return 0;
}
static int _wrap_SBBreakpointName_SetCommandLineCommands(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
lldb::SBStringList *arg2 = 0 ;
SWIG_check_num_args("lldb::SBBreakpointName::SetCommandLineCommands",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetCommandLineCommands",1,"lldb::SBBreakpointName *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetCommandLineCommands",2,"lldb::SBStringList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_SetCommandLineCommands",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBBreakpointName_SetCommandLineCommands",2,SWIGTYPE_p_lldb__SBStringList);
}
(arg1)->SetCommandLineCommands(*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_GetCommandLineCommands(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
lldb::SBStringList *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpointName::GetCommandLineCommands",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetCommandLineCommands",1,"lldb::SBBreakpointName *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::GetCommandLineCommands",2,"lldb::SBStringList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_GetCommandLineCommands",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBBreakpointName_GetCommandLineCommands",2,SWIGTYPE_p_lldb__SBStringList);
}
result = (bool)(arg1)->GetCommandLineCommands(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_SetScriptCallbackBody(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBBreakpointName::SetScriptCallbackBody",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetScriptCallbackBody",1,"lldb::SBBreakpointName *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetScriptCallbackBody",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_SetScriptCallbackBody",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->SetScriptCallbackBody((char const *)arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_GetHelpString(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBBreakpointName::GetHelpString",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetHelpString",1,"lldb::SBBreakpointName const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_GetHelpString",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
result = (char *)((lldb::SBBreakpointName const *)arg1)->GetHelpString();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_SetHelpString(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBBreakpointName::SetHelpString",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetHelpString",1,"lldb::SBBreakpointName *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetHelpString",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_SetHelpString",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetHelpString((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_GetAllowList(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpointName::GetAllowList",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetAllowList",1,"lldb::SBBreakpointName const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_GetAllowList",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
result = (bool)((lldb::SBBreakpointName const *)arg1)->GetAllowList();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_SetAllowList(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBBreakpointName::SetAllowList",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetAllowList",1,"lldb::SBBreakpointName *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetAllowList",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_SetAllowList",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetAllowList(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_GetAllowDelete(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpointName::GetAllowDelete",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetAllowDelete",1,"lldb::SBBreakpointName *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_GetAllowDelete",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
result = (bool)(arg1)->GetAllowDelete();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_SetAllowDelete(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBBreakpointName::SetAllowDelete",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetAllowDelete",1,"lldb::SBBreakpointName *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetAllowDelete",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_SetAllowDelete",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetAllowDelete(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_GetAllowDisable(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpointName::GetAllowDisable",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetAllowDisable",1,"lldb::SBBreakpointName *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_GetAllowDisable",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
result = (bool)(arg1)->GetAllowDisable();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_SetAllowDisable(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBBreakpointName::SetAllowDisable",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetAllowDisable",1,"lldb::SBBreakpointName *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetAllowDisable",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_SetAllowDisable",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetAllowDisable(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBBreakpointName::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetDescription",1,"lldb::SBBreakpointName *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName_GetDescription",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBBreakpointName_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBreakpointName___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBBreakpointName::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::__str__",1,"lldb::SBBreakpointName *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){
SWIG_fail_ptr("SBBreakpointName___tostring",1,SWIGTYPE_p_lldb__SBBreakpointName);
}
result = lldb_SBBreakpointName___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBBreakpointName(void *obj) {
lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBBreakpointName(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBBreakpointName);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBBreakpointName_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBBreakpointName_methods[]= {
{ "__eq", _wrap_SBBreakpointName___eq},
{ "IsValid", _wrap_SBBreakpointName_IsValid},
{ "GetName", _wrap_SBBreakpointName_GetName},
{ "SetEnabled", _wrap_SBBreakpointName_SetEnabled},
{ "IsEnabled", _wrap_SBBreakpointName_IsEnabled},
{ "SetOneShot", _wrap_SBBreakpointName_SetOneShot},
{ "IsOneShot", _wrap_SBBreakpointName_IsOneShot},
{ "SetIgnoreCount", _wrap_SBBreakpointName_SetIgnoreCount},
{ "GetIgnoreCount", _wrap_SBBreakpointName_GetIgnoreCount},
{ "SetCondition", _wrap_SBBreakpointName_SetCondition},
{ "GetCondition", _wrap_SBBreakpointName_GetCondition},
{ "SetAutoContinue", _wrap_SBBreakpointName_SetAutoContinue},
{ "GetAutoContinue", _wrap_SBBreakpointName_GetAutoContinue},
{ "SetThreadID", _wrap_SBBreakpointName_SetThreadID},
{ "GetThreadID", _wrap_SBBreakpointName_GetThreadID},
{ "SetThreadIndex", _wrap_SBBreakpointName_SetThreadIndex},
{ "GetThreadIndex", _wrap_SBBreakpointName_GetThreadIndex},
{ "SetThreadName", _wrap_SBBreakpointName_SetThreadName},
{ "GetThreadName", _wrap_SBBreakpointName_GetThreadName},
{ "SetQueueName", _wrap_SBBreakpointName_SetQueueName},
{ "GetQueueName", _wrap_SBBreakpointName_GetQueueName},
{ "SetScriptCallbackFunction", _wrap_SBBreakpointName_SetScriptCallbackFunction},
{ "SetCommandLineCommands", _wrap_SBBreakpointName_SetCommandLineCommands},
{ "GetCommandLineCommands", _wrap_SBBreakpointName_GetCommandLineCommands},
{ "SetScriptCallbackBody", _wrap_SBBreakpointName_SetScriptCallbackBody},
{ "GetHelpString", _wrap_SBBreakpointName_GetHelpString},
{ "SetHelpString", _wrap_SBBreakpointName_SetHelpString},
{ "GetAllowList", _wrap_SBBreakpointName_GetAllowList},
{ "SetAllowList", _wrap_SBBreakpointName_SetAllowList},
{ "GetAllowDelete", _wrap_SBBreakpointName_GetAllowDelete},
{ "SetAllowDelete", _wrap_SBBreakpointName_SetAllowDelete},
{ "GetAllowDisable", _wrap_SBBreakpointName_GetAllowDisable},
{ "SetAllowDisable", _wrap_SBBreakpointName_SetAllowDisable},
{ "GetDescription", _wrap_SBBreakpointName_GetDescription},
{ "__tostring", _wrap_SBBreakpointName___tostring},
{0,0}
};
static swig_lua_method swig_SBBreakpointName_meta[] = {
{ "__eq", _wrap_SBBreakpointName___eq},
{ "__tostring", _wrap_SBBreakpointName___tostring},
{0,0}
};
static swig_lua_attribute swig_SBBreakpointName_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBBreakpointName_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBBreakpointName_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBBreakpointName_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBBreakpointName_Sf_SwigStatic = {
"SBBreakpointName",
swig_SBBreakpointName_Sf_SwigStatic_methods,
swig_SBBreakpointName_Sf_SwigStatic_attributes,
swig_SBBreakpointName_Sf_SwigStatic_constants,
swig_SBBreakpointName_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBBreakpointName_bases[] = {0};
static const char *swig_SBBreakpointName_base_names[] = {0};
static swig_lua_class _wrap_class_SBBreakpointName = { "SBBreakpointName", "SBBreakpointName", &SWIGTYPE_p_lldb__SBBreakpointName,_proxy__wrap_new_SBBreakpointName, swig_delete_SBBreakpointName, swig_SBBreakpointName_methods, swig_SBBreakpointName_attributes, &swig_SBBreakpointName_Sf_SwigStatic, swig_SBBreakpointName_meta, swig_SBBreakpointName_bases, swig_SBBreakpointName_base_names };
static int _wrap_new_SBBroadcaster__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBroadcaster *result = 0 ;
SWIG_check_num_args("lldb::SBBroadcaster::SBBroadcaster",0,0)
result = (lldb::SBBroadcaster *)new lldb::SBBroadcaster();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBroadcaster,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBBroadcaster__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
lldb::SBBroadcaster *result = 0 ;
SWIG_check_num_args("lldb::SBBroadcaster::SBBroadcaster",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::SBBroadcaster",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = (lldb::SBBroadcaster *)new lldb::SBBroadcaster((char const *)arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBroadcaster,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBBroadcaster__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBroadcaster *arg1 = 0 ;
lldb::SBBroadcaster *result = 0 ;
SWIG_check_num_args("lldb::SBBroadcaster::SBBroadcaster",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::SBBroadcaster",1,"lldb::SBBroadcaster const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("new_SBBroadcaster",1,SWIGTYPE_p_lldb__SBBroadcaster);
}
result = (lldb::SBBroadcaster *)new lldb::SBBroadcaster((lldb::SBBroadcaster const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBroadcaster,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBBroadcaster(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBBroadcaster__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBroadcaster, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBBroadcaster__SWIG_2(L);
}
}
if (argc == 1) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
return _wrap_new_SBBroadcaster__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBBroadcaster'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBBroadcaster::SBBroadcaster()\n"
" lldb::SBBroadcaster::SBBroadcaster(char const *)\n"
" lldb::SBBroadcaster::SBBroadcaster(lldb::SBBroadcaster const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBBroadcaster_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBBroadcaster::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::IsValid",1,"lldb::SBBroadcaster const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBBroadcaster_IsValid",1,SWIGTYPE_p_lldb__SBBroadcaster);
}
result = (bool)((lldb::SBBroadcaster const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBroadcaster_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ;
SWIG_check_num_args("lldb::SBBroadcaster::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::Clear",1,"lldb::SBBroadcaster *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBBroadcaster_Clear",1,SWIGTYPE_p_lldb__SBBroadcaster);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBroadcaster_BroadcastEventByType__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ;
uint32_t arg2 ;
bool arg3 ;
SWIG_check_num_args("lldb::SBBroadcaster::BroadcastEventByType",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEventByType",1,"lldb::SBBroadcaster *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEventByType",2,"uint32_t");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEventByType",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBBroadcaster_BroadcastEventByType",1,SWIGTYPE_p_lldb__SBBroadcaster);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
arg3 = (lua_toboolean(L, 3)!=0);
(arg1)->BroadcastEventByType(arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBroadcaster_BroadcastEventByType__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBBroadcaster::BroadcastEventByType",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEventByType",1,"lldb::SBBroadcaster *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEventByType",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBBroadcaster_BroadcastEventByType",1,SWIGTYPE_p_lldb__SBBroadcaster);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->BroadcastEventByType(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBroadcaster_BroadcastEventByType(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBroadcaster, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBBroadcaster_BroadcastEventByType__SWIG_1(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBroadcaster, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[2]);
}
if (_v) {
return _wrap_SBBroadcaster_BroadcastEventByType__SWIG_0(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBBroadcaster_BroadcastEventByType'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBBroadcaster::BroadcastEventByType(uint32_t,bool)\n"
" lldb::SBBroadcaster::BroadcastEventByType(uint32_t)\n");
lua_error(L);return 0;
}
static int _wrap_SBBroadcaster_BroadcastEvent__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ;
lldb::SBEvent *arg2 = 0 ;
bool arg3 ;
SWIG_check_num_args("lldb::SBBroadcaster::BroadcastEvent",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEvent",1,"lldb::SBBroadcaster *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEvent",2,"lldb::SBEvent const &");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEvent",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBBroadcaster_BroadcastEvent",1,SWIGTYPE_p_lldb__SBBroadcaster);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBBroadcaster_BroadcastEvent",2,SWIGTYPE_p_lldb__SBEvent);
}
arg3 = (lua_toboolean(L, 3)!=0);
(arg1)->BroadcastEvent((lldb::SBEvent const &)*arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBroadcaster_BroadcastEvent__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ;
lldb::SBEvent *arg2 = 0 ;
SWIG_check_num_args("lldb::SBBroadcaster::BroadcastEvent",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEvent",1,"lldb::SBBroadcaster *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEvent",2,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBBroadcaster_BroadcastEvent",1,SWIGTYPE_p_lldb__SBBroadcaster);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBBroadcaster_BroadcastEvent",2,SWIGTYPE_p_lldb__SBEvent);
}
(arg1)->BroadcastEvent((lldb::SBEvent const &)*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBroadcaster_BroadcastEvent(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBroadcaster, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBBroadcaster_BroadcastEvent__SWIG_1(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBroadcaster, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[2]);
}
if (_v) {
return _wrap_SBBroadcaster_BroadcastEvent__SWIG_0(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBBroadcaster_BroadcastEvent'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBBroadcaster::BroadcastEvent(lldb::SBEvent const &,bool)\n"
" lldb::SBBroadcaster::BroadcastEvent(lldb::SBEvent const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBBroadcaster_AddInitialEventsToListener(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ;
lldb::SBListener *arg2 = 0 ;
uint32_t arg3 ;
SWIG_check_num_args("lldb::SBBroadcaster::AddInitialEventsToListener",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::AddInitialEventsToListener",1,"lldb::SBBroadcaster *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::AddInitialEventsToListener",2,"lldb::SBListener const &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBBroadcaster::AddInitialEventsToListener",3,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBBroadcaster_AddInitialEventsToListener",1,SWIGTYPE_p_lldb__SBBroadcaster);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBBroadcaster_AddInitialEventsToListener",2,SWIGTYPE_p_lldb__SBListener);
}
arg3 = (uint32_t)lua_tointeger(L, 3);
(arg1)->AddInitialEventsToListener((lldb::SBListener const &)*arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBroadcaster_AddListener(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ;
lldb::SBListener *arg2 = 0 ;
uint32_t arg3 ;
uint32_t result;
SWIG_check_num_args("lldb::SBBroadcaster::AddListener",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::AddListener",1,"lldb::SBBroadcaster *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::AddListener",2,"lldb::SBListener const &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBBroadcaster::AddListener",3,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBBroadcaster_AddListener",1,SWIGTYPE_p_lldb__SBBroadcaster);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBBroadcaster_AddListener",2,SWIGTYPE_p_lldb__SBListener);
}
arg3 = (uint32_t)lua_tointeger(L, 3);
result = (uint32_t)(arg1)->AddListener((lldb::SBListener const &)*arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBroadcaster_GetName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBBroadcaster::GetName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::GetName",1,"lldb::SBBroadcaster const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBBroadcaster_GetName",1,SWIGTYPE_p_lldb__SBBroadcaster);
}
result = (char *)((lldb::SBBroadcaster const *)arg1)->GetName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBroadcaster_EventTypeHasListeners(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ;
uint32_t arg2 ;
bool result;
SWIG_check_num_args("lldb::SBBroadcaster::EventTypeHasListeners",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::EventTypeHasListeners",1,"lldb::SBBroadcaster *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::EventTypeHasListeners",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBBroadcaster_EventTypeHasListeners",1,SWIGTYPE_p_lldb__SBBroadcaster);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (bool)(arg1)->EventTypeHasListeners(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBroadcaster_RemoveListener__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ;
lldb::SBListener *arg2 = 0 ;
uint32_t arg3 ;
bool result;
SWIG_check_num_args("lldb::SBBroadcaster::RemoveListener",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::RemoveListener",1,"lldb::SBBroadcaster *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::RemoveListener",2,"lldb::SBListener const &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBBroadcaster::RemoveListener",3,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBBroadcaster_RemoveListener",1,SWIGTYPE_p_lldb__SBBroadcaster);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBBroadcaster_RemoveListener",2,SWIGTYPE_p_lldb__SBListener);
}
arg3 = (uint32_t)lua_tointeger(L, 3);
result = (bool)(arg1)->RemoveListener((lldb::SBListener const &)*arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBroadcaster_RemoveListener__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ;
lldb::SBListener *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBBroadcaster::RemoveListener",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::RemoveListener",1,"lldb::SBBroadcaster *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::RemoveListener",2,"lldb::SBListener const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBBroadcaster_RemoveListener",1,SWIGTYPE_p_lldb__SBBroadcaster);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBBroadcaster_RemoveListener",2,SWIGTYPE_p_lldb__SBListener);
}
result = (bool)(arg1)->RemoveListener((lldb::SBListener const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBBroadcaster_RemoveListener(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBroadcaster, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBBroadcaster_RemoveListener__SWIG_1(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBroadcaster, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBBroadcaster_RemoveListener__SWIG_0(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBBroadcaster_RemoveListener'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBBroadcaster::RemoveListener(lldb::SBListener const &,uint32_t)\n"
" lldb::SBBroadcaster::RemoveListener(lldb::SBListener const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBBroadcaster___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ;
lldb::SBBroadcaster *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBBroadcaster::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::operator ==",1,"lldb::SBBroadcaster const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::operator ==",2,"lldb::SBBroadcaster const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBBroadcaster___eq",1,SWIGTYPE_p_lldb__SBBroadcaster);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBBroadcaster___eq",2,SWIGTYPE_p_lldb__SBBroadcaster);
}
result = (bool)((lldb::SBBroadcaster const *)arg1)->operator ==((lldb::SBBroadcaster const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBBroadcaster(void *obj) {
lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBBroadcaster(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBBroadcaster);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBBroadcaster_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBBroadcaster_methods[]= {
{ "IsValid", _wrap_SBBroadcaster_IsValid},
{ "Clear", _wrap_SBBroadcaster_Clear},
{ "BroadcastEventByType", _wrap_SBBroadcaster_BroadcastEventByType},
{ "BroadcastEvent", _wrap_SBBroadcaster_BroadcastEvent},
{ "AddInitialEventsToListener", _wrap_SBBroadcaster_AddInitialEventsToListener},
{ "AddListener", _wrap_SBBroadcaster_AddListener},
{ "GetName", _wrap_SBBroadcaster_GetName},
{ "EventTypeHasListeners", _wrap_SBBroadcaster_EventTypeHasListeners},
{ "RemoveListener", _wrap_SBBroadcaster_RemoveListener},
{ "__eq", _wrap_SBBroadcaster___eq},
{0,0}
};
static swig_lua_method swig_SBBroadcaster_meta[] = {
{ "__eq", _wrap_SBBroadcaster___eq},
{0,0}
};
static swig_lua_attribute swig_SBBroadcaster_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBBroadcaster_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBBroadcaster_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBBroadcaster_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBBroadcaster_Sf_SwigStatic = {
"SBBroadcaster",
swig_SBBroadcaster_Sf_SwigStatic_methods,
swig_SBBroadcaster_Sf_SwigStatic_attributes,
swig_SBBroadcaster_Sf_SwigStatic_constants,
swig_SBBroadcaster_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBBroadcaster_bases[] = {0};
static const char *swig_SBBroadcaster_base_names[] = {0};
static swig_lua_class _wrap_class_SBBroadcaster = { "SBBroadcaster", "SBBroadcaster", &SWIGTYPE_p_lldb__SBBroadcaster,_proxy__wrap_new_SBBroadcaster, swig_delete_SBBroadcaster, swig_SBBroadcaster_methods, swig_SBBroadcaster_attributes, &swig_SBBroadcaster_Sf_SwigStatic, swig_SBBroadcaster_meta, swig_SBBroadcaster_bases, swig_SBBroadcaster_base_names };
static int _wrap_new_SBCommandInterpreter(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = 0 ;
lldb::SBCommandInterpreter *result = 0 ;
SWIG_check_num_args("lldb::SBCommandInterpreter::SBCommandInterpreter",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::SBCommandInterpreter",1,"lldb::SBCommandInterpreter const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("new_SBCommandInterpreter",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
result = (lldb::SBCommandInterpreter *)new lldb::SBCommandInterpreter((lldb::SBCommandInterpreter const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBCommandInterpreter,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_GetArgumentTypeAsCString(lua_State* L) {
int SWIG_arg = 0;
lldb::CommandArgumentType arg1 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBCommandInterpreter::GetArgumentTypeAsCString",1,1)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetArgumentTypeAsCString",1,"lldb::CommandArgumentType const");
arg1 = (lldb::CommandArgumentType const)lua_tointeger(L, 1);
result = (char *)lldb::SBCommandInterpreter::GetArgumentTypeAsCString(arg1);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_GetArgumentDescriptionAsCString(lua_State* L) {
int SWIG_arg = 0;
lldb::CommandArgumentType arg1 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBCommandInterpreter::GetArgumentDescriptionAsCString",1,1)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetArgumentDescriptionAsCString",1,"lldb::CommandArgumentType const");
arg1 = (lldb::CommandArgumentType const)lua_tointeger(L, 1);
result = (char *)lldb::SBCommandInterpreter::GetArgumentDescriptionAsCString(arg1);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_EventIsCommandInterpreterEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandInterpreter::EventIsCommandInterpreterEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::EventIsCommandInterpreterEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBCommandInterpreter_EventIsCommandInterpreterEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)lldb::SBCommandInterpreter::EventIsCommandInterpreterEvent((lldb::SBEvent const &)*arg1);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandInterpreter::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::IsValid",1,"lldb::SBCommandInterpreter const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_IsValid",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
result = (bool)((lldb::SBCommandInterpreter const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_GetIOHandlerControlSequence(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
char arg2 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBCommandInterpreter::GetIOHandlerControlSequence",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetIOHandlerControlSequence",1,"lldb::SBCommandInterpreter *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetIOHandlerControlSequence",2,"char");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_GetIOHandlerControlSequence",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
arg2 = (lua_tostring(L, 2))[0];
result = (char *)(arg1)->GetIOHandlerControlSequence(arg2);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_GetPromptOnQuit(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandInterpreter::GetPromptOnQuit",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetPromptOnQuit",1,"lldb::SBCommandInterpreter *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_GetPromptOnQuit",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
result = (bool)(arg1)->GetPromptOnQuit();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_SetPromptOnQuit(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBCommandInterpreter::SetPromptOnQuit",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::SetPromptOnQuit",1,"lldb::SBCommandInterpreter *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::SetPromptOnQuit",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_SetPromptOnQuit",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetPromptOnQuit(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_AllowExitCodeOnQuit(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBCommandInterpreter::AllowExitCodeOnQuit",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::AllowExitCodeOnQuit",1,"lldb::SBCommandInterpreter *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::AllowExitCodeOnQuit",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_AllowExitCodeOnQuit",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->AllowExitCodeOnQuit(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_HasCustomQuitExitCode(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandInterpreter::HasCustomQuitExitCode",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HasCustomQuitExitCode",1,"lldb::SBCommandInterpreter *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_HasCustomQuitExitCode",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
result = (bool)(arg1)->HasCustomQuitExitCode();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_GetQuitStatus(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
int result;
SWIG_check_num_args("lldb::SBCommandInterpreter::GetQuitStatus",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetQuitStatus",1,"lldb::SBCommandInterpreter *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_GetQuitStatus",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
result = (int)(arg1)->GetQuitStatus();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_ResolveCommand(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBCommandReturnObject *arg3 = 0 ;
SWIG_check_num_args("lldb::SBCommandInterpreter::ResolveCommand",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::ResolveCommand",1,"lldb::SBCommandInterpreter *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::ResolveCommand",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBCommandInterpreter::ResolveCommand",3,"lldb::SBCommandReturnObject &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_ResolveCommand",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandInterpreter_ResolveCommand",3,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
(arg1)->ResolveCommand((char const *)arg2,*arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_CommandExists(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
char *arg2 = (char *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandInterpreter::CommandExists",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::CommandExists",1,"lldb::SBCommandInterpreter *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::CommandExists",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_CommandExists",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
arg2 = (char *)lua_tostring(L, 2);
result = (bool)(arg1)->CommandExists((char const *)arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_AliasExists(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
char *arg2 = (char *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandInterpreter::AliasExists",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::AliasExists",1,"lldb::SBCommandInterpreter *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::AliasExists",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_AliasExists",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
arg2 = (char *)lua_tostring(L, 2);
result = (bool)(arg1)->AliasExists((char const *)arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_GetBroadcaster(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
lldb::SBBroadcaster result;
SWIG_check_num_args("lldb::SBCommandInterpreter::GetBroadcaster",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetBroadcaster",1,"lldb::SBCommandInterpreter *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_GetBroadcaster",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
result = (arg1)->GetBroadcaster();
{
lldb::SBBroadcaster * resultptr = new lldb::SBBroadcaster((const lldb::SBBroadcaster &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBroadcaster,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_GetBroadcasterClass(lua_State* L) {
int SWIG_arg = 0;
char *result = 0 ;
SWIG_check_num_args("lldb::SBCommandInterpreter::GetBroadcasterClass",0,0)
result = (char *)lldb::SBCommandInterpreter::GetBroadcasterClass();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_HasCommands(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandInterpreter::HasCommands",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HasCommands",1,"lldb::SBCommandInterpreter *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_HasCommands",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
result = (bool)(arg1)->HasCommands();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_HasAliases(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandInterpreter::HasAliases",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HasAliases",1,"lldb::SBCommandInterpreter *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_HasAliases",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
result = (bool)(arg1)->HasAliases();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_HasAliasOptions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandInterpreter::HasAliasOptions",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HasAliasOptions",1,"lldb::SBCommandInterpreter *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_HasAliasOptions",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
result = (bool)(arg1)->HasAliasOptions();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_GetProcess(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
lldb::SBProcess result;
SWIG_check_num_args("lldb::SBCommandInterpreter::GetProcess",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetProcess",1,"lldb::SBCommandInterpreter *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_GetProcess",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
result = (arg1)->GetProcess();
{
lldb::SBProcess * resultptr = new lldb::SBProcess((const lldb::SBProcess &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_GetDebugger(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
lldb::SBDebugger result;
SWIG_check_num_args("lldb::SBCommandInterpreter::GetDebugger",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetDebugger",1,"lldb::SBCommandInterpreter *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_GetDebugger",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
result = (arg1)->GetDebugger();
{
lldb::SBDebugger * resultptr = new lldb::SBDebugger((const lldb::SBDebugger &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBDebugger,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_SourceInitFileInHomeDirectory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
lldb::SBCommandReturnObject *arg2 = 0 ;
SWIG_check_num_args("lldb::SBCommandInterpreter::SourceInitFileInHomeDirectory",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::SourceInitFileInHomeDirectory",1,"lldb::SBCommandInterpreter *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::SourceInitFileInHomeDirectory",2,"lldb::SBCommandReturnObject &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_SourceInitFileInHomeDirectory",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandInterpreter_SourceInitFileInHomeDirectory",2,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
(arg1)->SourceInitFileInHomeDirectory(*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
lldb::SBCommandReturnObject *arg2 = 0 ;
SWIG_check_num_args("lldb::SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory",1,"lldb::SBCommandInterpreter *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory",2,"lldb::SBCommandReturnObject &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory",2,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
(arg1)->SourceInitFileInCurrentWorkingDirectory(*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_HandleCommand__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBCommandReturnObject *arg3 = 0 ;
bool arg4 ;
lldb::ReturnStatus result;
SWIG_check_num_args("lldb::SBCommandInterpreter::HandleCommand",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",1,"lldb::SBCommandInterpreter *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",3,"lldb::SBCommandReturnObject &");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",4,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",3,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
arg4 = (lua_toboolean(L, 4)!=0);
result = (lldb::ReturnStatus)(arg1)->HandleCommand((char const *)arg2,*arg3,arg4);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_HandleCommand__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBCommandReturnObject *arg3 = 0 ;
lldb::ReturnStatus result;
SWIG_check_num_args("lldb::SBCommandInterpreter::HandleCommand",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",1,"lldb::SBCommandInterpreter *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",3,"lldb::SBCommandReturnObject &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",3,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
result = (lldb::ReturnStatus)(arg1)->HandleCommand((char const *)arg2,*arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_HandleCommand__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBExecutionContext *arg3 = 0 ;
lldb::SBCommandReturnObject *arg4 = 0 ;
bool arg5 ;
lldb::ReturnStatus result;
SWIG_check_num_args("lldb::SBCommandInterpreter::HandleCommand",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",1,"lldb::SBCommandInterpreter *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",3,"lldb::SBExecutionContext &");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",4,"lldb::SBCommandReturnObject &");
if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",5,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBExecutionContext,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",3,SWIGTYPE_p_lldb__SBExecutionContext);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",4,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
arg5 = (lua_toboolean(L, 5)!=0);
result = (lldb::ReturnStatus)(arg1)->HandleCommand((char const *)arg2,*arg3,*arg4,arg5);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_HandleCommand__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBExecutionContext *arg3 = 0 ;
lldb::SBCommandReturnObject *arg4 = 0 ;
lldb::ReturnStatus result;
SWIG_check_num_args("lldb::SBCommandInterpreter::HandleCommand",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",1,"lldb::SBCommandInterpreter *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",3,"lldb::SBExecutionContext &");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",4,"lldb::SBCommandReturnObject &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBExecutionContext,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",3,SWIGTYPE_p_lldb__SBExecutionContext);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",4,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
result = (lldb::ReturnStatus)(arg1)->HandleCommand((char const *)arg2,*arg3,*arg4);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_HandleCommand(lua_State* L) {
int argc;
int argv[6]={
1,2,3,4,5,6
};
argc = lua_gettop(L);
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandInterpreter, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBCommandInterpreter_HandleCommand__SWIG_1(L);
}
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandInterpreter, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[3]);
}
if (_v) {
return _wrap_SBCommandInterpreter_HandleCommand__SWIG_0(L);
}
}
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandInterpreter, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBExecutionContext, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBCommandInterpreter_HandleCommand__SWIG_3(L);
}
}
}
}
}
if (argc == 5) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandInterpreter, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBExecutionContext, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[4]);
}
if (_v) {
return _wrap_SBCommandInterpreter_HandleCommand__SWIG_2(L);
}
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBCommandInterpreter_HandleCommand'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBCommandInterpreter::HandleCommand(char const *,lldb::SBCommandReturnObject &,bool)\n"
" lldb::SBCommandInterpreter::HandleCommand(char const *,lldb::SBCommandReturnObject &)\n"
" lldb::SBCommandInterpreter::HandleCommand(char const *,lldb::SBExecutionContext &,lldb::SBCommandReturnObject &,bool)\n"
" lldb::SBCommandInterpreter::HandleCommand(char const *,lldb::SBExecutionContext &,lldb::SBCommandReturnObject &)\n");
lua_error(L);return 0;
}
static int _wrap_SBCommandInterpreter_HandleCommandsFromFile(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
lldb::SBExecutionContext *arg3 = 0 ;
lldb::SBCommandInterpreterRunOptions *arg4 = 0 ;
lldb::SBCommandReturnObject arg5 ;
lldb::SBCommandReturnObject *argp5 ;
SWIG_check_num_args("lldb::SBCommandInterpreter::HandleCommandsFromFile",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommandsFromFile",1,"lldb::SBCommandInterpreter *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommandsFromFile",2,"lldb::SBFileSpec &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommandsFromFile",3,"lldb::SBExecutionContext &");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommandsFromFile",4,"lldb::SBCommandInterpreterRunOptions &");
if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommandsFromFile",5,"lldb::SBCommandReturnObject");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCommandsFromFile",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCommandsFromFile",2,SWIGTYPE_p_lldb__SBFileSpec);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBExecutionContext,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCommandsFromFile",3,SWIGTYPE_p_lldb__SBExecutionContext);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCommandsFromFile",4,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&argp5,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCommandsFromFile",5,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
arg5 = *argp5;
(arg1)->HandleCommandsFromFile(*arg2,*arg3,*arg4,arg5);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_HandleCompletion(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
char *arg2 = (char *) 0 ;
uint32_t arg3 ;
int arg4 ;
int arg5 ;
lldb::SBStringList *arg6 = 0 ;
int result;
SWIG_check_num_args("lldb::SBCommandInterpreter::HandleCompletion",6,6)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletion",1,"lldb::SBCommandInterpreter *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletion",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletion",3,"uint32_t");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletion",4,"int");
if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletion",5,"int");
if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletion",6,"lldb::SBStringList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCompletion",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
arg4 = (int)lua_tointeger(L, 4);
arg5 = (int)lua_tointeger(L, 5);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCompletion",6,SWIGTYPE_p_lldb__SBStringList);
}
result = (int)(arg1)->HandleCompletion((char const *)arg2,arg3,arg4,arg5,*arg6);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_HandleCompletionWithDescriptions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
char *arg2 = (char *) 0 ;
uint32_t arg3 ;
int arg4 ;
int arg5 ;
lldb::SBStringList *arg6 = 0 ;
lldb::SBStringList *arg7 = 0 ;
int result;
SWIG_check_num_args("lldb::SBCommandInterpreter::HandleCompletionWithDescriptions",7,7)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletionWithDescriptions",1,"lldb::SBCommandInterpreter *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletionWithDescriptions",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletionWithDescriptions",3,"uint32_t");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletionWithDescriptions",4,"int");
if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletionWithDescriptions",5,"int");
if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletionWithDescriptions",6,"lldb::SBStringList &");
if(!lua_isuserdata(L,7)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletionWithDescriptions",7,"lldb::SBStringList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCompletionWithDescriptions",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
arg4 = (int)lua_tointeger(L, 4);
arg5 = (int)lua_tointeger(L, 5);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCompletionWithDescriptions",6,SWIGTYPE_p_lldb__SBStringList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBCommandInterpreter_HandleCompletionWithDescriptions",7,SWIGTYPE_p_lldb__SBStringList);
}
result = (int)(arg1)->HandleCompletionWithDescriptions((char const *)arg2,arg3,arg4,arg5,*arg6,*arg7);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_IsActive(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandInterpreter::IsActive",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::IsActive",1,"lldb::SBCommandInterpreter *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_IsActive",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
result = (bool)(arg1)->IsActive();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreter_WasInterrupted(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandInterpreter::WasInterrupted",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::WasInterrupted",1,"lldb::SBCommandInterpreter const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){
SWIG_fail_ptr("SBCommandInterpreter_WasInterrupted",1,SWIGTYPE_p_lldb__SBCommandInterpreter);
}
result = (bool)((lldb::SBCommandInterpreter const *)arg1)->WasInterrupted();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBCommandInterpreter(void *obj) {
lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBCommandInterpreter(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBCommandInterpreter);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBCommandInterpreter_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBCommandInterpreter_methods[]= {
{ "IsValid", _wrap_SBCommandInterpreter_IsValid},
{ "GetIOHandlerControlSequence", _wrap_SBCommandInterpreter_GetIOHandlerControlSequence},
{ "GetPromptOnQuit", _wrap_SBCommandInterpreter_GetPromptOnQuit},
{ "SetPromptOnQuit", _wrap_SBCommandInterpreter_SetPromptOnQuit},
{ "AllowExitCodeOnQuit", _wrap_SBCommandInterpreter_AllowExitCodeOnQuit},
{ "HasCustomQuitExitCode", _wrap_SBCommandInterpreter_HasCustomQuitExitCode},
{ "GetQuitStatus", _wrap_SBCommandInterpreter_GetQuitStatus},
{ "ResolveCommand", _wrap_SBCommandInterpreter_ResolveCommand},
{ "CommandExists", _wrap_SBCommandInterpreter_CommandExists},
{ "AliasExists", _wrap_SBCommandInterpreter_AliasExists},
{ "GetBroadcaster", _wrap_SBCommandInterpreter_GetBroadcaster},
{ "HasCommands", _wrap_SBCommandInterpreter_HasCommands},
{ "HasAliases", _wrap_SBCommandInterpreter_HasAliases},
{ "HasAliasOptions", _wrap_SBCommandInterpreter_HasAliasOptions},
{ "GetProcess", _wrap_SBCommandInterpreter_GetProcess},
{ "GetDebugger", _wrap_SBCommandInterpreter_GetDebugger},
{ "SourceInitFileInHomeDirectory", _wrap_SBCommandInterpreter_SourceInitFileInHomeDirectory},
{ "SourceInitFileInCurrentWorkingDirectory", _wrap_SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory},
{ "HandleCommand", _wrap_SBCommandInterpreter_HandleCommand},
{ "HandleCommandsFromFile", _wrap_SBCommandInterpreter_HandleCommandsFromFile},
{ "HandleCompletion", _wrap_SBCommandInterpreter_HandleCompletion},
{ "HandleCompletionWithDescriptions", _wrap_SBCommandInterpreter_HandleCompletionWithDescriptions},
{ "IsActive", _wrap_SBCommandInterpreter_IsActive},
{ "WasInterrupted", _wrap_SBCommandInterpreter_WasInterrupted},
{0,0}
};
static swig_lua_method swig_SBCommandInterpreter_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBCommandInterpreter_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBCommandInterpreter_Sf_SwigStatic_constants[]= {
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitThreadShouldExit", lldb::SBCommandInterpreter::eBroadcastBitThreadShouldExit)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitResetPrompt", lldb::SBCommandInterpreter::eBroadcastBitResetPrompt)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitQuitCommandReceived", lldb::SBCommandInterpreter::eBroadcastBitQuitCommandReceived)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitAsynchronousOutputData", lldb::SBCommandInterpreter::eBroadcastBitAsynchronousOutputData)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitAsynchronousErrorData", lldb::SBCommandInterpreter::eBroadcastBitAsynchronousErrorData)},
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBCommandInterpreter_Sf_SwigStatic_methods[]= {
{ "GetArgumentTypeAsCString", _wrap_SBCommandInterpreter_GetArgumentTypeAsCString},
{ "GetArgumentDescriptionAsCString", _wrap_SBCommandInterpreter_GetArgumentDescriptionAsCString},
{ "EventIsCommandInterpreterEvent", _wrap_SBCommandInterpreter_EventIsCommandInterpreterEvent},
{ "GetBroadcasterClass", _wrap_SBCommandInterpreter_GetBroadcasterClass},
{0,0}
};
static swig_lua_class* swig_SBCommandInterpreter_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBCommandInterpreter_Sf_SwigStatic = {
"SBCommandInterpreter",
swig_SBCommandInterpreter_Sf_SwigStatic_methods,
swig_SBCommandInterpreter_Sf_SwigStatic_attributes,
swig_SBCommandInterpreter_Sf_SwigStatic_constants,
swig_SBCommandInterpreter_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBCommandInterpreter_bases[] = {0};
static const char *swig_SBCommandInterpreter_base_names[] = {0};
static swig_lua_class _wrap_class_SBCommandInterpreter = { "SBCommandInterpreter", "SBCommandInterpreter", &SWIGTYPE_p_lldb__SBCommandInterpreter,_proxy__wrap_new_SBCommandInterpreter, swig_delete_SBCommandInterpreter, swig_SBCommandInterpreter_methods, swig_SBCommandInterpreter_attributes, &swig_SBCommandInterpreter_Sf_SwigStatic, swig_SBCommandInterpreter_meta, swig_SBCommandInterpreter_bases, swig_SBCommandInterpreter_base_names };
static int _wrap_new_SBCommandInterpreterRunOptions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreterRunOptions *result = 0 ;
SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions",0,0)
result = (lldb::SBCommandInterpreterRunOptions *)new lldb::SBCommandInterpreterRunOptions();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreterRunOptions_GetStopOnContinue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::GetStopOnContinue",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::GetStopOnContinue",1,"lldb::SBCommandInterpreterRunOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){
SWIG_fail_ptr("SBCommandInterpreterRunOptions_GetStopOnContinue",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions);
}
result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetStopOnContinue();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreterRunOptions_SetStopOnContinue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SetStopOnContinue",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetStopOnContinue",1,"lldb::SBCommandInterpreterRunOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetStopOnContinue",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){
SWIG_fail_ptr("SBCommandInterpreterRunOptions_SetStopOnContinue",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetStopOnContinue(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreterRunOptions_GetStopOnError(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::GetStopOnError",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::GetStopOnError",1,"lldb::SBCommandInterpreterRunOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){
SWIG_fail_ptr("SBCommandInterpreterRunOptions_GetStopOnError",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions);
}
result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetStopOnError();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreterRunOptions_SetStopOnError(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SetStopOnError",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetStopOnError",1,"lldb::SBCommandInterpreterRunOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetStopOnError",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){
SWIG_fail_ptr("SBCommandInterpreterRunOptions_SetStopOnError",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetStopOnError(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreterRunOptions_GetStopOnCrash(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::GetStopOnCrash",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::GetStopOnCrash",1,"lldb::SBCommandInterpreterRunOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){
SWIG_fail_ptr("SBCommandInterpreterRunOptions_GetStopOnCrash",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions);
}
result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetStopOnCrash();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreterRunOptions_SetStopOnCrash(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SetStopOnCrash",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetStopOnCrash",1,"lldb::SBCommandInterpreterRunOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetStopOnCrash",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){
SWIG_fail_ptr("SBCommandInterpreterRunOptions_SetStopOnCrash",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetStopOnCrash(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreterRunOptions_GetEchoCommands(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::GetEchoCommands",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::GetEchoCommands",1,"lldb::SBCommandInterpreterRunOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){
SWIG_fail_ptr("SBCommandInterpreterRunOptions_GetEchoCommands",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions);
}
result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetEchoCommands();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreterRunOptions_SetEchoCommands(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SetEchoCommands",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetEchoCommands",1,"lldb::SBCommandInterpreterRunOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetEchoCommands",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){
SWIG_fail_ptr("SBCommandInterpreterRunOptions_SetEchoCommands",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetEchoCommands(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreterRunOptions_GetPrintResults(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::GetPrintResults",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::GetPrintResults",1,"lldb::SBCommandInterpreterRunOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){
SWIG_fail_ptr("SBCommandInterpreterRunOptions_GetPrintResults",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions);
}
result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetPrintResults();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreterRunOptions_SetPrintResults(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SetPrintResults",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetPrintResults",1,"lldb::SBCommandInterpreterRunOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetPrintResults",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){
SWIG_fail_ptr("SBCommandInterpreterRunOptions_SetPrintResults",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetPrintResults(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreterRunOptions_GetPrintErrors(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::GetPrintErrors",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::GetPrintErrors",1,"lldb::SBCommandInterpreterRunOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){
SWIG_fail_ptr("SBCommandInterpreterRunOptions_GetPrintErrors",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions);
}
result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetPrintErrors();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreterRunOptions_SetPrintErrors(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SetPrintErrors",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetPrintErrors",1,"lldb::SBCommandInterpreterRunOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetPrintErrors",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){
SWIG_fail_ptr("SBCommandInterpreterRunOptions_SetPrintErrors",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetPrintErrors(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreterRunOptions_GetAddToHistory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::GetAddToHistory",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::GetAddToHistory",1,"lldb::SBCommandInterpreterRunOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){
SWIG_fail_ptr("SBCommandInterpreterRunOptions_GetAddToHistory",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions);
}
result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetAddToHistory();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandInterpreterRunOptions_SetAddToHistory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SetAddToHistory",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetAddToHistory",1,"lldb::SBCommandInterpreterRunOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetAddToHistory",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){
SWIG_fail_ptr("SBCommandInterpreterRunOptions_SetAddToHistory",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetAddToHistory(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBCommandInterpreterRunOptions(void *obj) {
lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBCommandInterpreterRunOptions(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBCommandInterpreterRunOptions);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBCommandInterpreterRunOptions_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBCommandInterpreterRunOptions_methods[]= {
{ "GetStopOnContinue", _wrap_SBCommandInterpreterRunOptions_GetStopOnContinue},
{ "SetStopOnContinue", _wrap_SBCommandInterpreterRunOptions_SetStopOnContinue},
{ "GetStopOnError", _wrap_SBCommandInterpreterRunOptions_GetStopOnError},
{ "SetStopOnError", _wrap_SBCommandInterpreterRunOptions_SetStopOnError},
{ "GetStopOnCrash", _wrap_SBCommandInterpreterRunOptions_GetStopOnCrash},
{ "SetStopOnCrash", _wrap_SBCommandInterpreterRunOptions_SetStopOnCrash},
{ "GetEchoCommands", _wrap_SBCommandInterpreterRunOptions_GetEchoCommands},
{ "SetEchoCommands", _wrap_SBCommandInterpreterRunOptions_SetEchoCommands},
{ "GetPrintResults", _wrap_SBCommandInterpreterRunOptions_GetPrintResults},
{ "SetPrintResults", _wrap_SBCommandInterpreterRunOptions_SetPrintResults},
{ "GetPrintErrors", _wrap_SBCommandInterpreterRunOptions_GetPrintErrors},
{ "SetPrintErrors", _wrap_SBCommandInterpreterRunOptions_SetPrintErrors},
{ "GetAddToHistory", _wrap_SBCommandInterpreterRunOptions_GetAddToHistory},
{ "SetAddToHistory", _wrap_SBCommandInterpreterRunOptions_SetAddToHistory},
{0,0}
};
static swig_lua_method swig_SBCommandInterpreterRunOptions_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBCommandInterpreterRunOptions_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBCommandInterpreterRunOptions_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBCommandInterpreterRunOptions_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBCommandInterpreterRunOptions_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBCommandInterpreterRunOptions_Sf_SwigStatic = {
"SBCommandInterpreterRunOptions",
swig_SBCommandInterpreterRunOptions_Sf_SwigStatic_methods,
swig_SBCommandInterpreterRunOptions_Sf_SwigStatic_attributes,
swig_SBCommandInterpreterRunOptions_Sf_SwigStatic_constants,
swig_SBCommandInterpreterRunOptions_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBCommandInterpreterRunOptions_bases[] = {0};
static const char *swig_SBCommandInterpreterRunOptions_base_names[] = {0};
static swig_lua_class _wrap_class_SBCommandInterpreterRunOptions = { "SBCommandInterpreterRunOptions", "SBCommandInterpreterRunOptions", &SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,_proxy__wrap_new_SBCommandInterpreterRunOptions, swig_delete_SBCommandInterpreterRunOptions, swig_SBCommandInterpreterRunOptions_methods, swig_SBCommandInterpreterRunOptions_attributes, &swig_SBCommandInterpreterRunOptions_Sf_SwigStatic, swig_SBCommandInterpreterRunOptions_meta, swig_SBCommandInterpreterRunOptions_bases, swig_SBCommandInterpreterRunOptions_base_names };
static int _wrap_new_SBCommandReturnObject__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *result = 0 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::SBCommandReturnObject",0,0)
result = (lldb::SBCommandReturnObject *)new lldb::SBCommandReturnObject();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBCommandReturnObject,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBCommandReturnObject__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = 0 ;
lldb::SBCommandReturnObject *result = 0 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::SBCommandReturnObject",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SBCommandReturnObject",1,"lldb::SBCommandReturnObject const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("new_SBCommandReturnObject",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
result = (lldb::SBCommandReturnObject *)new lldb::SBCommandReturnObject((lldb::SBCommandReturnObject const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBCommandReturnObject,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBCommandReturnObject(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBCommandReturnObject__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBCommandReturnObject__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBCommandReturnObject'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBCommandReturnObject::SBCommandReturnObject()\n"
" lldb::SBCommandReturnObject::SBCommandReturnObject(lldb::SBCommandReturnObject const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBCommandReturnObject_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandReturnObject::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::IsValid",1,"lldb::SBCommandReturnObject const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_IsValid",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
result = (bool)((lldb::SBCommandReturnObject const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_GetOutput__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::GetOutput",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetOutput",1,"lldb::SBCommandReturnObject *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_GetOutput",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
result = (char *)(arg1)->GetOutput();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_GetError__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::GetError",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetError",1,"lldb::SBCommandReturnObject *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_GetError",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
result = (char *)(arg1)->GetError();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_GetOutputSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBCommandReturnObject::GetOutputSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetOutputSize",1,"lldb::SBCommandReturnObject *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_GetOutputSize",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
result = (arg1)->GetOutputSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_GetErrorSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBCommandReturnObject::GetErrorSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetErrorSize",1,"lldb::SBCommandReturnObject *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_GetErrorSize",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
result = (arg1)->GetErrorSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_GetOutput__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
bool arg2 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::GetOutput",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetOutput",1,"lldb::SBCommandReturnObject *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetOutput",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_GetOutput",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
arg2 = (lua_toboolean(L, 2)!=0);
result = (char *)(arg1)->GetOutput(arg2);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_GetOutput(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBCommandReturnObject_GetOutput__SWIG_0(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_SBCommandReturnObject_GetOutput__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBCommandReturnObject_GetOutput'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBCommandReturnObject::GetOutput()\n"
" lldb::SBCommandReturnObject::GetOutput(bool)\n");
lua_error(L);return 0;
}
static int _wrap_SBCommandReturnObject_GetError__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
bool arg2 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::GetError",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetError",1,"lldb::SBCommandReturnObject *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetError",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_GetError",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
arg2 = (lua_toboolean(L, 2)!=0);
result = (char *)(arg1)->GetError(arg2);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_GetError(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBCommandReturnObject_GetError__SWIG_0(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_SBCommandReturnObject_GetError__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBCommandReturnObject_GetError'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBCommandReturnObject::GetError()\n"
" lldb::SBCommandReturnObject::GetError(bool)\n");
lua_error(L);return 0;
}
static int _wrap_SBCommandReturnObject_PutOutput__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
lldb::SBFile arg2 ;
lldb::SBFile *argp2 ;
size_t result;
SWIG_check_num_args("lldb::SBCommandReturnObject::PutOutput",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::PutOutput",1,"lldb::SBCommandReturnObject *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::PutOutput",2,"lldb::SBFile");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_PutOutput",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBCommandReturnObject_PutOutput",2,SWIGTYPE_p_lldb__SBFile);
}
arg2 = *argp2;
result = (arg1)->PutOutput(arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_PutError__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
lldb::SBFile arg2 ;
lldb::SBFile *argp2 ;
size_t result;
SWIG_check_num_args("lldb::SBCommandReturnObject::PutError",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::PutError",1,"lldb::SBCommandReturnObject *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::PutError",2,"lldb::SBFile");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_PutError",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBCommandReturnObject_PutError",2,SWIGTYPE_p_lldb__SBFile);
}
arg2 = *argp2;
result = (arg1)->PutError(arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_PutOutput__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
size_t result;
SWIG_check_num_args("lldb::SBCommandReturnObject::PutOutput",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::PutOutput",1,"lldb::SBCommandReturnObject *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_PutOutput",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg2 = file_sp;
}
result = (arg1)->PutOutput(arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_PutOutput(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBCommandReturnObject_PutOutput__SWIG_0(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_isuserdata(L, argv[1])) &&
(luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr);
}
if (_v) {
return _wrap_SBCommandReturnObject_PutOutput__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBCommandReturnObject_PutOutput'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBCommandReturnObject::PutOutput(lldb::SBFile)\n"
" lldb::SBCommandReturnObject::PutOutput(lldb::FileSP)\n");
lua_error(L);return 0;
}
static int _wrap_SBCommandReturnObject_PutError__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
size_t result;
SWIG_check_num_args("lldb::SBCommandReturnObject::PutError",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::PutError",1,"lldb::SBCommandReturnObject *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_PutError",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg2 = file_sp;
}
result = (arg1)->PutError(arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_PutError(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBCommandReturnObject_PutError__SWIG_0(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_isuserdata(L, argv[1])) &&
(luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr);
}
if (_v) {
return _wrap_SBCommandReturnObject_PutError__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBCommandReturnObject_PutError'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBCommandReturnObject::PutError(lldb::SBFile)\n"
" lldb::SBCommandReturnObject::PutError(lldb::FileSP)\n");
lua_error(L);return 0;
}
static int _wrap_SBCommandReturnObject_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::Clear",1,"lldb::SBCommandReturnObject *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_Clear",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_SetStatus(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
lldb::ReturnStatus arg2 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::SetStatus",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetStatus",1,"lldb::SBCommandReturnObject *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetStatus",2,"lldb::ReturnStatus");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_SetStatus",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
arg2 = (lldb::ReturnStatus)lua_tointeger(L, 2);
(arg1)->SetStatus(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_SetError__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
lldb::SBError *arg2 = 0 ;
char *arg3 = (char *) 0 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::SetError",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetError",1,"lldb::SBCommandReturnObject *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetError",2,"lldb::SBError &");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetError",3,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_SetError",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBCommandReturnObject_SetError",2,SWIGTYPE_p_lldb__SBError);
}
arg3 = (char *)lua_tostring(L, 3);
(arg1)->SetError(*arg2,(char const *)arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_SetError__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
lldb::SBError *arg2 = 0 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::SetError",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetError",1,"lldb::SBCommandReturnObject *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetError",2,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_SetError",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBCommandReturnObject_SetError",2,SWIGTYPE_p_lldb__SBError);
}
(arg1)->SetError(*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_SetError__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::SetError",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetError",1,"lldb::SBCommandReturnObject *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetError",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_SetError",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetError((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_SetError(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBCommandReturnObject_SetError__SWIG_1(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBCommandReturnObject_SetError__SWIG_2(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[2]);
}
if (_v) {
return _wrap_SBCommandReturnObject_SetError__SWIG_0(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBCommandReturnObject_SetError'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBCommandReturnObject::SetError(lldb::SBError &,char const *)\n"
" lldb::SBCommandReturnObject::SetError(lldb::SBError &)\n"
" lldb::SBCommandReturnObject::SetError(char const *)\n");
lua_error(L);return 0;
}
static int _wrap_SBCommandReturnObject_GetStatus(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
lldb::ReturnStatus result;
SWIG_check_num_args("lldb::SBCommandReturnObject::GetStatus",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetStatus",1,"lldb::SBCommandReturnObject *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_GetStatus",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
result = (lldb::ReturnStatus)(arg1)->GetStatus();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_Succeeded(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandReturnObject::Succeeded",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::Succeeded",1,"lldb::SBCommandReturnObject *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_Succeeded",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
result = (bool)(arg1)->Succeeded();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_HasResult(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandReturnObject::HasResult",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::HasResult",1,"lldb::SBCommandReturnObject *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_HasResult",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
result = (bool)(arg1)->HasResult();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_AppendMessage(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::AppendMessage",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::AppendMessage",1,"lldb::SBCommandReturnObject *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::AppendMessage",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_AppendMessage",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->AppendMessage((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_AppendWarning(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::AppendWarning",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::AppendWarning",1,"lldb::SBCommandReturnObject *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::AppendWarning",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_AppendWarning",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->AppendWarning((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommandReturnObject::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetDescription",1,"lldb::SBCommandReturnObject *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_GetDescription",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBCommandReturnObject_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
lldb::SBFile arg2 ;
lldb::SBFile *argp2 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::SetImmediateOutputFile",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateOutputFile",1,"lldb::SBCommandReturnObject *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateOutputFile",2,"lldb::SBFile");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_SetImmediateOutputFile",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBCommandReturnObject_SetImmediateOutputFile",2,SWIGTYPE_p_lldb__SBFile);
}
arg2 = *argp2;
(arg1)->SetImmediateOutputFile(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
lldb::SBFile arg2 ;
lldb::SBFile *argp2 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::SetImmediateErrorFile",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateErrorFile",1,"lldb::SBCommandReturnObject *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateErrorFile",2,"lldb::SBFile");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_SetImmediateErrorFile",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBCommandReturnObject_SetImmediateErrorFile",2,SWIGTYPE_p_lldb__SBFile);
}
arg2 = *argp2;
(arg1)->SetImmediateErrorFile(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::SetImmediateOutputFile",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateOutputFile",1,"lldb::SBCommandReturnObject *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_SetImmediateOutputFile",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg2 = file_sp;
}
(arg1)->SetImmediateOutputFile(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::SetImmediateErrorFile",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateErrorFile",1,"lldb::SBCommandReturnObject *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_SetImmediateErrorFile",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg2 = file_sp;
}
(arg1)->SetImmediateErrorFile(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBCommandReturnObject::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::__str__",1,"lldb::SBCommandReturnObject *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject___tostring",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
result = lldb_SBCommandReturnObject___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
bool arg3 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::SetImmediateOutputFile",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateOutputFile",1,"lldb::SBCommandReturnObject *");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateOutputFile",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_SetImmediateOutputFile",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg2 = file_sp;
}
arg3 = (lua_toboolean(L, 3)!=0);
lldb_SBCommandReturnObject_SetImmediateOutputFile__SWIG_2(arg1,arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_SetImmediateOutputFile(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_0(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_isuserdata(L, argv[1])) &&
(luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr);
}
if (_v) {
return _wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_1(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_isuserdata(L, argv[1])) &&
(luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr);
}
if (_v) {
{
_v = lua_isboolean(L,argv[2]);
}
if (_v) {
return _wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_2(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBCommandReturnObject_SetImmediateOutputFile'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBCommandReturnObject::SetImmediateOutputFile(lldb::SBFile)\n"
" lldb::SBCommandReturnObject::SetImmediateOutputFile(lldb::FileSP)\n"
" lldb::SBCommandReturnObject::SetImmediateOutputFile(lldb::FileSP,bool)\n");
lua_error(L);return 0;
}
static int _wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
bool arg3 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::SetImmediateErrorFile",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateErrorFile",1,"lldb::SBCommandReturnObject *");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateErrorFile",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_SetImmediateErrorFile",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg2 = file_sp;
}
arg3 = (lua_toboolean(L, 3)!=0);
lldb_SBCommandReturnObject_SetImmediateErrorFile__SWIG_2(arg1,arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_SetImmediateErrorFile(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_0(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_isuserdata(L, argv[1])) &&
(luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr);
}
if (_v) {
return _wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_1(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_isuserdata(L, argv[1])) &&
(luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr);
}
if (_v) {
{
_v = lua_isboolean(L,argv[2]);
}
if (_v) {
return _wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_2(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBCommandReturnObject_SetImmediateErrorFile'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBCommandReturnObject::SetImmediateErrorFile(lldb::SBFile)\n"
" lldb::SBCommandReturnObject::SetImmediateErrorFile(lldb::FileSP)\n"
" lldb::SBCommandReturnObject::SetImmediateErrorFile(lldb::FileSP,bool)\n");
lua_error(L);return 0;
}
static int _wrap_SBCommandReturnObject_PutCString(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
char *arg2 = (char *) 0 ;
int arg3 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::PutCString",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::PutCString",1,"lldb::SBCommandReturnObject *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_PutCString",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
{
if (lua_isnil(L, 2)) {
arg2 = NULL;
arg3 = 0;
} else {
arg2 = (char *)luaL_checklstring(L, 2, (size_t *)&arg3);
}
}
(arg1)->PutCString((char const *)arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommandReturnObject_Print(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBCommandReturnObject::Print",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::Print",1,"lldb::SBCommandReturnObject *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::Print",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBCommandReturnObject_Print",1,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
arg2 = (char *)lua_tostring(L, 2);
lldb_SBCommandReturnObject_Print(arg1,(char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBCommandReturnObject(void *obj) {
lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBCommandReturnObject(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBCommandReturnObject);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBCommandReturnObject_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBCommandReturnObject_methods[]= {
{ "IsValid", _wrap_SBCommandReturnObject_IsValid},
{ "GetOutputSize", _wrap_SBCommandReturnObject_GetOutputSize},
{ "GetErrorSize", _wrap_SBCommandReturnObject_GetErrorSize},
{ "GetOutput", _wrap_SBCommandReturnObject_GetOutput},
{ "GetError", _wrap_SBCommandReturnObject_GetError},
{ "PutOutput", _wrap_SBCommandReturnObject_PutOutput},
{ "PutError", _wrap_SBCommandReturnObject_PutError},
{ "Clear", _wrap_SBCommandReturnObject_Clear},
{ "SetStatus", _wrap_SBCommandReturnObject_SetStatus},
{ "SetError", _wrap_SBCommandReturnObject_SetError},
{ "GetStatus", _wrap_SBCommandReturnObject_GetStatus},
{ "Succeeded", _wrap_SBCommandReturnObject_Succeeded},
{ "HasResult", _wrap_SBCommandReturnObject_HasResult},
{ "AppendMessage", _wrap_SBCommandReturnObject_AppendMessage},
{ "AppendWarning", _wrap_SBCommandReturnObject_AppendWarning},
{ "GetDescription", _wrap_SBCommandReturnObject_GetDescription},
{ "__tostring", _wrap_SBCommandReturnObject___tostring},
{ "SetImmediateOutputFile", _wrap_SBCommandReturnObject_SetImmediateOutputFile},
{ "SetImmediateErrorFile", _wrap_SBCommandReturnObject_SetImmediateErrorFile},
{ "PutCString", _wrap_SBCommandReturnObject_PutCString},
{ "Print", _wrap_SBCommandReturnObject_Print},
{0,0}
};
static swig_lua_method swig_SBCommandReturnObject_meta[] = {
{ "__tostring", _wrap_SBCommandReturnObject___tostring},
{0,0}
};
static swig_lua_attribute swig_SBCommandReturnObject_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBCommandReturnObject_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBCommandReturnObject_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBCommandReturnObject_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBCommandReturnObject_Sf_SwigStatic = {
"SBCommandReturnObject",
swig_SBCommandReturnObject_Sf_SwigStatic_methods,
swig_SBCommandReturnObject_Sf_SwigStatic_attributes,
swig_SBCommandReturnObject_Sf_SwigStatic_constants,
swig_SBCommandReturnObject_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBCommandReturnObject_bases[] = {0};
static const char *swig_SBCommandReturnObject_base_names[] = {0};
static swig_lua_class _wrap_class_SBCommandReturnObject = { "SBCommandReturnObject", "SBCommandReturnObject", &SWIGTYPE_p_lldb__SBCommandReturnObject,_proxy__wrap_new_SBCommandReturnObject, swig_delete_SBCommandReturnObject, swig_SBCommandReturnObject_methods, swig_SBCommandReturnObject_attributes, &swig_SBCommandReturnObject_Sf_SwigStatic, swig_SBCommandReturnObject_meta, swig_SBCommandReturnObject_bases, swig_SBCommandReturnObject_base_names };
static int _wrap_new_SBCommunication__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommunication *result = 0 ;
SWIG_check_num_args("lldb::SBCommunication::SBCommunication",0,0)
result = (lldb::SBCommunication *)new lldb::SBCommunication();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBCommunication,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBCommunication__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
lldb::SBCommunication *result = 0 ;
SWIG_check_num_args("lldb::SBCommunication::SBCommunication",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBCommunication::SBCommunication",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = (lldb::SBCommunication *)new lldb::SBCommunication((char const *)arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBCommunication,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBCommunication(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBCommunication__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
return _wrap_new_SBCommunication__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBCommunication'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBCommunication::SBCommunication()\n"
" lldb::SBCommunication::SBCommunication(char const *)\n");
lua_error(L);return 0;
}
static int _wrap_SBCommunication_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommunication::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::IsValid",1,"lldb::SBCommunication const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){
SWIG_fail_ptr("SBCommunication_IsValid",1,SWIGTYPE_p_lldb__SBCommunication);
}
result = (bool)((lldb::SBCommunication const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommunication_GetBroadcaster(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ;
lldb::SBBroadcaster result;
SWIG_check_num_args("lldb::SBCommunication::GetBroadcaster",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::GetBroadcaster",1,"lldb::SBCommunication *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){
SWIG_fail_ptr("SBCommunication_GetBroadcaster",1,SWIGTYPE_p_lldb__SBCommunication);
}
result = (arg1)->GetBroadcaster();
{
lldb::SBBroadcaster * resultptr = new lldb::SBBroadcaster((const lldb::SBBroadcaster &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBroadcaster,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommunication_GetBroadcasterClass(lua_State* L) {
int SWIG_arg = 0;
char *result = 0 ;
SWIG_check_num_args("lldb::SBCommunication::GetBroadcasterClass",0,0)
result = (char *)lldb::SBCommunication::GetBroadcasterClass();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommunication_AdoptFileDesriptor(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ;
int arg2 ;
bool arg3 ;
lldb::ConnectionStatus result;
SWIG_check_num_args("lldb::SBCommunication::AdoptFileDesriptor",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::AdoptFileDesriptor",1,"lldb::SBCommunication *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBCommunication::AdoptFileDesriptor",2,"int");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBCommunication::AdoptFileDesriptor",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){
SWIG_fail_ptr("SBCommunication_AdoptFileDesriptor",1,SWIGTYPE_p_lldb__SBCommunication);
}
arg2 = (int)lua_tointeger(L, 2);
arg3 = (lua_toboolean(L, 3)!=0);
result = (lldb::ConnectionStatus)(arg1)->AdoptFileDesriptor(arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommunication_Connect(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ;
char *arg2 = (char *) 0 ;
lldb::ConnectionStatus result;
SWIG_check_num_args("lldb::SBCommunication::Connect",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::Connect",1,"lldb::SBCommunication *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommunication::Connect",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){
SWIG_fail_ptr("SBCommunication_Connect",1,SWIGTYPE_p_lldb__SBCommunication);
}
arg2 = (char *)lua_tostring(L, 2);
result = (lldb::ConnectionStatus)(arg1)->Connect((char const *)arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommunication_Disconnect(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ;
lldb::ConnectionStatus result;
SWIG_check_num_args("lldb::SBCommunication::Disconnect",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::Disconnect",1,"lldb::SBCommunication *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){
SWIG_fail_ptr("SBCommunication_Disconnect",1,SWIGTYPE_p_lldb__SBCommunication);
}
result = (lldb::ConnectionStatus)(arg1)->Disconnect();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommunication_IsConnected(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommunication::IsConnected",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::IsConnected",1,"lldb::SBCommunication const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){
SWIG_fail_ptr("SBCommunication_IsConnected",1,SWIGTYPE_p_lldb__SBCommunication);
}
result = (bool)((lldb::SBCommunication const *)arg1)->IsConnected();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommunication_GetCloseOnEOF(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommunication::GetCloseOnEOF",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::GetCloseOnEOF",1,"lldb::SBCommunication *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){
SWIG_fail_ptr("SBCommunication_GetCloseOnEOF",1,SWIGTYPE_p_lldb__SBCommunication);
}
result = (bool)(arg1)->GetCloseOnEOF();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommunication_SetCloseOnEOF(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBCommunication::SetCloseOnEOF",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::SetCloseOnEOF",1,"lldb::SBCommunication *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommunication::SetCloseOnEOF",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){
SWIG_fail_ptr("SBCommunication_SetCloseOnEOF",1,SWIGTYPE_p_lldb__SBCommunication);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetCloseOnEOF(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommunication_Read(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ;
void *arg2 = (void *) 0 ;
size_t arg3 ;
uint32_t arg4 ;
lldb::ConnectionStatus *arg5 = 0 ;
size_t result;
SWIG_check_num_args("lldb::SBCommunication::Read",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::Read",1,"lldb::SBCommunication *");
if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBCommunication::Read",2,"void *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBCommunication::Read",3,"size_t");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBCommunication::Read",4,"uint32_t");
if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBCommunication::Read",5,"lldb::ConnectionStatus &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){
SWIG_fail_ptr("SBCommunication_Read",1,SWIGTYPE_p_lldb__SBCommunication);
}
arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"SBCommunication_Read");
arg3 = (size_t)lua_tointeger(L, 3);
arg4 = (uint32_t)lua_tointeger(L, 4);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__ConnectionStatus,0))){
SWIG_fail_ptr("SBCommunication_Read",5,SWIGTYPE_p_lldb__ConnectionStatus);
}
result = (arg1)->Read(arg2,arg3,arg4,*arg5);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommunication_Write(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ;
void *arg2 = (void *) 0 ;
size_t arg3 ;
lldb::ConnectionStatus *arg4 = 0 ;
size_t result;
SWIG_check_num_args("lldb::SBCommunication::Write",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::Write",1,"lldb::SBCommunication *");
if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBCommunication::Write",2,"void const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBCommunication::Write",3,"size_t");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBCommunication::Write",4,"lldb::ConnectionStatus &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){
SWIG_fail_ptr("SBCommunication_Write",1,SWIGTYPE_p_lldb__SBCommunication);
}
arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"SBCommunication_Write");
arg3 = (size_t)lua_tointeger(L, 3);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__ConnectionStatus,0))){
SWIG_fail_ptr("SBCommunication_Write",4,SWIGTYPE_p_lldb__ConnectionStatus);
}
result = (arg1)->Write((void const *)arg2,arg3,*arg4);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommunication_ReadThreadStart(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommunication::ReadThreadStart",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::ReadThreadStart",1,"lldb::SBCommunication *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){
SWIG_fail_ptr("SBCommunication_ReadThreadStart",1,SWIGTYPE_p_lldb__SBCommunication);
}
result = (bool)(arg1)->ReadThreadStart();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommunication_ReadThreadStop(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommunication::ReadThreadStop",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::ReadThreadStop",1,"lldb::SBCommunication *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){
SWIG_fail_ptr("SBCommunication_ReadThreadStop",1,SWIGTYPE_p_lldb__SBCommunication);
}
result = (bool)(arg1)->ReadThreadStop();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommunication_ReadThreadIsRunning(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommunication::ReadThreadIsRunning",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::ReadThreadIsRunning",1,"lldb::SBCommunication *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){
SWIG_fail_ptr("SBCommunication_ReadThreadIsRunning",1,SWIGTYPE_p_lldb__SBCommunication);
}
result = (bool)(arg1)->ReadThreadIsRunning();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCommunication_SetReadThreadBytesReceivedCallback(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ;
lldb::SBCommunication::ReadThreadBytesReceived arg2 = (lldb::SBCommunication::ReadThreadBytesReceived) 0 ;
void *arg3 = (void *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCommunication::SetReadThreadBytesReceivedCallback",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::SetReadThreadBytesReceivedCallback",1,"lldb::SBCommunication *");
if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBCommunication::SetReadThreadBytesReceivedCallback",2,"lldb::SBCommunication::ReadThreadBytesReceived");
if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("lldb::SBCommunication::SetReadThreadBytesReceivedCallback",3,"void *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){
SWIG_fail_ptr("SBCommunication_SetReadThreadBytesReceivedCallback",1,SWIGTYPE_p_lldb__SBCommunication);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_f_p_void_p_q_const__void_size_t__void,0))){
SWIG_fail_ptr("SBCommunication_SetReadThreadBytesReceivedCallback",2,SWIGTYPE_p_f_p_void_p_q_const__void_size_t__void);
}
arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"SBCommunication_SetReadThreadBytesReceivedCallback");
result = (bool)(arg1)->SetReadThreadBytesReceivedCallback(arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBCommunication(void *obj) {
lldb::SBCommunication *arg1 = (lldb::SBCommunication *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBCommunication(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBCommunication);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBCommunication_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBCommunication_methods[]= {
{ "IsValid", _wrap_SBCommunication_IsValid},
{ "GetBroadcaster", _wrap_SBCommunication_GetBroadcaster},
{ "AdoptFileDesriptor", _wrap_SBCommunication_AdoptFileDesriptor},
{ "Connect", _wrap_SBCommunication_Connect},
{ "Disconnect", _wrap_SBCommunication_Disconnect},
{ "IsConnected", _wrap_SBCommunication_IsConnected},
{ "GetCloseOnEOF", _wrap_SBCommunication_GetCloseOnEOF},
{ "SetCloseOnEOF", _wrap_SBCommunication_SetCloseOnEOF},
{ "Read", _wrap_SBCommunication_Read},
{ "Write", _wrap_SBCommunication_Write},
{ "ReadThreadStart", _wrap_SBCommunication_ReadThreadStart},
{ "ReadThreadStop", _wrap_SBCommunication_ReadThreadStop},
{ "ReadThreadIsRunning", _wrap_SBCommunication_ReadThreadIsRunning},
{ "SetReadThreadBytesReceivedCallback", _wrap_SBCommunication_SetReadThreadBytesReceivedCallback},
{0,0}
};
static swig_lua_method swig_SBCommunication_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBCommunication_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBCommunication_Sf_SwigStatic_constants[]= {
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitDisconnected", lldb::SBCommunication::eBroadcastBitDisconnected)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitReadThreadGotBytes", lldb::SBCommunication::eBroadcastBitReadThreadGotBytes)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitReadThreadDidExit", lldb::SBCommunication::eBroadcastBitReadThreadDidExit)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitReadThreadShouldExit", lldb::SBCommunication::eBroadcastBitReadThreadShouldExit)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitPacketAvailable", lldb::SBCommunication::eBroadcastBitPacketAvailable)},
{SWIG_LUA_CONSTTAB_INT("eAllEventBits", lldb::SBCommunication::eAllEventBits)},
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBCommunication_Sf_SwigStatic_methods[]= {
{ "GetBroadcasterClass", _wrap_SBCommunication_GetBroadcasterClass},
{0,0}
};
static swig_lua_class* swig_SBCommunication_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBCommunication_Sf_SwigStatic = {
"SBCommunication",
swig_SBCommunication_Sf_SwigStatic_methods,
swig_SBCommunication_Sf_SwigStatic_attributes,
swig_SBCommunication_Sf_SwigStatic_constants,
swig_SBCommunication_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBCommunication_bases[] = {0};
static const char *swig_SBCommunication_base_names[] = {0};
static swig_lua_class _wrap_class_SBCommunication = { "SBCommunication", "SBCommunication", &SWIGTYPE_p_lldb__SBCommunication,_proxy__wrap_new_SBCommunication, swig_delete_SBCommunication, swig_SBCommunication_methods, swig_SBCommunication_attributes, &swig_SBCommunication_Sf_SwigStatic, swig_SBCommunication_meta, swig_SBCommunication_bases, swig_SBCommunication_base_names };
static int _wrap_new_SBCompileUnit__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCompileUnit *result = 0 ;
SWIG_check_num_args("lldb::SBCompileUnit::SBCompileUnit",0,0)
result = (lldb::SBCompileUnit *)new lldb::SBCompileUnit();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBCompileUnit,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBCompileUnit__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCompileUnit *arg1 = 0 ;
lldb::SBCompileUnit *result = 0 ;
SWIG_check_num_args("lldb::SBCompileUnit::SBCompileUnit",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::SBCompileUnit",1,"lldb::SBCompileUnit const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){
SWIG_fail_ptr("new_SBCompileUnit",1,SWIGTYPE_p_lldb__SBCompileUnit);
}
result = (lldb::SBCompileUnit *)new lldb::SBCompileUnit((lldb::SBCompileUnit const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBCompileUnit,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBCompileUnit(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBCompileUnit__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCompileUnit, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBCompileUnit__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBCompileUnit'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBCompileUnit::SBCompileUnit()\n"
" lldb::SBCompileUnit::SBCompileUnit(lldb::SBCompileUnit const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBCompileUnit_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBCompileUnit::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::IsValid",1,"lldb::SBCompileUnit const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){
SWIG_fail_ptr("SBCompileUnit_IsValid",1,SWIGTYPE_p_lldb__SBCompileUnit);
}
result = (bool)((lldb::SBCompileUnit const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCompileUnit_GetFileSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBCompileUnit::GetFileSpec",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::GetFileSpec",1,"lldb::SBCompileUnit const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){
SWIG_fail_ptr("SBCompileUnit_GetFileSpec",1,SWIGTYPE_p_lldb__SBCompileUnit);
}
result = ((lldb::SBCompileUnit const *)arg1)->GetFileSpec();
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCompileUnit_GetNumLineEntries(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBCompileUnit::GetNumLineEntries",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::GetNumLineEntries",1,"lldb::SBCompileUnit const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){
SWIG_fail_ptr("SBCompileUnit_GetNumLineEntries",1,SWIGTYPE_p_lldb__SBCompileUnit);
}
result = (uint32_t)((lldb::SBCompileUnit const *)arg1)->GetNumLineEntries();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCompileUnit_GetLineEntryAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ;
uint32_t arg2 ;
lldb::SBLineEntry result;
SWIG_check_num_args("lldb::SBCompileUnit::GetLineEntryAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::GetLineEntryAtIndex",1,"lldb::SBCompileUnit const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBCompileUnit::GetLineEntryAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){
SWIG_fail_ptr("SBCompileUnit_GetLineEntryAtIndex",1,SWIGTYPE_p_lldb__SBCompileUnit);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = ((lldb::SBCompileUnit const *)arg1)->GetLineEntryAtIndex(arg2);
{
lldb::SBLineEntry * resultptr = new lldb::SBLineEntry((const lldb::SBLineEntry &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBLineEntry,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCompileUnit_FindLineEntryIndex__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ;
uint32_t arg2 ;
uint32_t arg3 ;
lldb::SBFileSpec *arg4 = (lldb::SBFileSpec *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBCompileUnit::FindLineEntryIndex",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",1,"lldb::SBCompileUnit const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",2,"uint32_t");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",3,"uint32_t");
if(!SWIG_isptrtype(L,4)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",4,"lldb::SBFileSpec *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){
SWIG_fail_ptr("SBCompileUnit_FindLineEntryIndex",1,SWIGTYPE_p_lldb__SBCompileUnit);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBCompileUnit_FindLineEntryIndex",4,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (uint32_t)((lldb::SBCompileUnit const *)arg1)->FindLineEntryIndex(arg2,arg3,arg4);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCompileUnit_FindLineEntryIndex__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ;
uint32_t arg2 ;
uint32_t arg3 ;
lldb::SBFileSpec *arg4 = (lldb::SBFileSpec *) 0 ;
bool arg5 ;
uint32_t result;
SWIG_check_num_args("lldb::SBCompileUnit::FindLineEntryIndex",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",1,"lldb::SBCompileUnit const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",2,"uint32_t");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",3,"uint32_t");
if(!SWIG_isptrtype(L,4)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",4,"lldb::SBFileSpec *");
if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",5,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){
SWIG_fail_ptr("SBCompileUnit_FindLineEntryIndex",1,SWIGTYPE_p_lldb__SBCompileUnit);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBCompileUnit_FindLineEntryIndex",4,SWIGTYPE_p_lldb__SBFileSpec);
}
arg5 = (lua_toboolean(L, 5)!=0);
result = (uint32_t)((lldb::SBCompileUnit const *)arg1)->FindLineEntryIndex(arg2,arg3,arg4,arg5);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCompileUnit_FindLineEntryIndex(lua_State* L) {
int argc;
int argv[6]={
1,2,3,4,5,6
};
argc = lua_gettop(L);
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCompileUnit, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
void *ptr;
if (SWIG_isptrtype(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBCompileUnit_FindLineEntryIndex__SWIG_0(L);
}
}
}
}
}
if (argc == 5) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCompileUnit, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
void *ptr;
if (SWIG_isptrtype(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[4]);
}
if (_v) {
return _wrap_SBCompileUnit_FindLineEntryIndex__SWIG_1(L);
}
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBCompileUnit_FindLineEntryIndex'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBCompileUnit::FindLineEntryIndex(uint32_t,uint32_t,lldb::SBFileSpec *) const\n"
" lldb::SBCompileUnit::FindLineEntryIndex(uint32_t,uint32_t,lldb::SBFileSpec *,bool) const\n");
lua_error(L);return 0;
}
static int _wrap_SBCompileUnit_GetSupportFileAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ;
uint32_t arg2 ;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBCompileUnit::GetSupportFileAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::GetSupportFileAtIndex",1,"lldb::SBCompileUnit const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBCompileUnit::GetSupportFileAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){
SWIG_fail_ptr("SBCompileUnit_GetSupportFileAtIndex",1,SWIGTYPE_p_lldb__SBCompileUnit);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = ((lldb::SBCompileUnit const *)arg1)->GetSupportFileAtIndex(arg2);
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCompileUnit_GetNumSupportFiles(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBCompileUnit::GetNumSupportFiles",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::GetNumSupportFiles",1,"lldb::SBCompileUnit const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){
SWIG_fail_ptr("SBCompileUnit_GetNumSupportFiles",1,SWIGTYPE_p_lldb__SBCompileUnit);
}
result = (uint32_t)((lldb::SBCompileUnit const *)arg1)->GetNumSupportFiles();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCompileUnit_FindSupportFileIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ;
uint32_t arg2 ;
lldb::SBFileSpec *arg3 = 0 ;
bool arg4 ;
uint32_t result;
SWIG_check_num_args("lldb::SBCompileUnit::FindSupportFileIndex",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::FindSupportFileIndex",1,"lldb::SBCompileUnit *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBCompileUnit::FindSupportFileIndex",2,"uint32_t");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBCompileUnit::FindSupportFileIndex",3,"lldb::SBFileSpec const &");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBCompileUnit::FindSupportFileIndex",4,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){
SWIG_fail_ptr("SBCompileUnit_FindSupportFileIndex",1,SWIGTYPE_p_lldb__SBCompileUnit);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBCompileUnit_FindSupportFileIndex",3,SWIGTYPE_p_lldb__SBFileSpec);
}
arg4 = (lua_toboolean(L, 4)!=0);
result = (uint32_t)(arg1)->FindSupportFileIndex(arg2,(lldb::SBFileSpec const &)*arg3,arg4);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCompileUnit_GetTypes__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ;
uint32_t arg2 ;
lldb::SBTypeList result;
SWIG_check_num_args("lldb::SBCompileUnit::GetTypes",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::GetTypes",1,"lldb::SBCompileUnit *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBCompileUnit::GetTypes",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){
SWIG_fail_ptr("SBCompileUnit_GetTypes",1,SWIGTYPE_p_lldb__SBCompileUnit);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetTypes(arg2);
{
lldb::SBTypeList * resultptr = new lldb::SBTypeList((const lldb::SBTypeList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCompileUnit_GetTypes__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ;
lldb::SBTypeList result;
SWIG_check_num_args("lldb::SBCompileUnit::GetTypes",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::GetTypes",1,"lldb::SBCompileUnit *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){
SWIG_fail_ptr("SBCompileUnit_GetTypes",1,SWIGTYPE_p_lldb__SBCompileUnit);
}
result = (arg1)->GetTypes();
{
lldb::SBTypeList * resultptr = new lldb::SBTypeList((const lldb::SBTypeList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCompileUnit_GetTypes(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCompileUnit, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBCompileUnit_GetTypes__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCompileUnit, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBCompileUnit_GetTypes__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBCompileUnit_GetTypes'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBCompileUnit::GetTypes(uint32_t)\n"
" lldb::SBCompileUnit::GetTypes()\n");
lua_error(L);return 0;
}
static int _wrap_SBCompileUnit_GetLanguage(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ;
lldb::LanguageType result;
SWIG_check_num_args("lldb::SBCompileUnit::GetLanguage",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::GetLanguage",1,"lldb::SBCompileUnit *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){
SWIG_fail_ptr("SBCompileUnit_GetLanguage",1,SWIGTYPE_p_lldb__SBCompileUnit);
}
result = (lldb::LanguageType)(arg1)->GetLanguage();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCompileUnit_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBCompileUnit::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::GetDescription",1,"lldb::SBCompileUnit *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCompileUnit::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){
SWIG_fail_ptr("SBCompileUnit_GetDescription",1,SWIGTYPE_p_lldb__SBCompileUnit);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBCompileUnit_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCompileUnit___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ;
lldb::SBCompileUnit *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBCompileUnit::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::operator ==",1,"lldb::SBCompileUnit const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCompileUnit::operator ==",2,"lldb::SBCompileUnit const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){
SWIG_fail_ptr("SBCompileUnit___eq",1,SWIGTYPE_p_lldb__SBCompileUnit);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBCompileUnit,0))){
SWIG_fail_ptr("SBCompileUnit___eq",2,SWIGTYPE_p_lldb__SBCompileUnit);
}
result = (bool)((lldb::SBCompileUnit const *)arg1)->operator ==((lldb::SBCompileUnit const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBCompileUnit___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBCompileUnit::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::__str__",1,"lldb::SBCompileUnit *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){
SWIG_fail_ptr("SBCompileUnit___tostring",1,SWIGTYPE_p_lldb__SBCompileUnit);
}
result = lldb_SBCompileUnit___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBCompileUnit(void *obj) {
lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBCompileUnit(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBCompileUnit);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBCompileUnit_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBCompileUnit_methods[]= {
{ "IsValid", _wrap_SBCompileUnit_IsValid},
{ "GetFileSpec", _wrap_SBCompileUnit_GetFileSpec},
{ "GetNumLineEntries", _wrap_SBCompileUnit_GetNumLineEntries},
{ "GetLineEntryAtIndex", _wrap_SBCompileUnit_GetLineEntryAtIndex},
{ "FindLineEntryIndex", _wrap_SBCompileUnit_FindLineEntryIndex},
{ "GetSupportFileAtIndex", _wrap_SBCompileUnit_GetSupportFileAtIndex},
{ "GetNumSupportFiles", _wrap_SBCompileUnit_GetNumSupportFiles},
{ "FindSupportFileIndex", _wrap_SBCompileUnit_FindSupportFileIndex},
{ "GetTypes", _wrap_SBCompileUnit_GetTypes},
{ "GetLanguage", _wrap_SBCompileUnit_GetLanguage},
{ "GetDescription", _wrap_SBCompileUnit_GetDescription},
{ "__eq", _wrap_SBCompileUnit___eq},
{ "__tostring", _wrap_SBCompileUnit___tostring},
{0,0}
};
static swig_lua_method swig_SBCompileUnit_meta[] = {
{ "__eq", _wrap_SBCompileUnit___eq},
{ "__tostring", _wrap_SBCompileUnit___tostring},
{0,0}
};
static swig_lua_attribute swig_SBCompileUnit_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBCompileUnit_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBCompileUnit_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBCompileUnit_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBCompileUnit_Sf_SwigStatic = {
"SBCompileUnit",
swig_SBCompileUnit_Sf_SwigStatic_methods,
swig_SBCompileUnit_Sf_SwigStatic_attributes,
swig_SBCompileUnit_Sf_SwigStatic_constants,
swig_SBCompileUnit_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBCompileUnit_bases[] = {0};
static const char *swig_SBCompileUnit_base_names[] = {0};
static swig_lua_class _wrap_class_SBCompileUnit = { "SBCompileUnit", "SBCompileUnit", &SWIGTYPE_p_lldb__SBCompileUnit,_proxy__wrap_new_SBCompileUnit, swig_delete_SBCompileUnit, swig_SBCompileUnit_methods, swig_SBCompileUnit_attributes, &swig_SBCompileUnit_Sf_SwigStatic, swig_SBCompileUnit_meta, swig_SBCompileUnit_bases, swig_SBCompileUnit_base_names };
static int _wrap_new_SBData__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *result = 0 ;
SWIG_check_num_args("lldb::SBData::SBData",0,0)
result = (lldb::SBData *)new lldb::SBData();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBData__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = 0 ;
lldb::SBData *result = 0 ;
SWIG_check_num_args("lldb::SBData::SBData",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBData::SBData",1,"lldb::SBData const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("new_SBData",1,SWIGTYPE_p_lldb__SBData);
}
result = (lldb::SBData *)new lldb::SBData((lldb::SBData const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBData(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBData__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBData, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBData__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBData'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBData::SBData()\n"
" lldb::SBData::SBData(lldb::SBData const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBData_GetAddressByteSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
uint8_t result;
SWIG_check_num_args("lldb::SBData::GetAddressByteSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetAddressByteSize",1,"lldb::SBData *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_GetAddressByteSize",1,SWIGTYPE_p_lldb__SBData);
}
result = (uint8_t)(arg1)->GetAddressByteSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_SetAddressByteSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
uint8_t arg2 ;
SWIG_check_num_args("lldb::SBData::SetAddressByteSize",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetAddressByteSize",1,"lldb::SBData *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBData::SetAddressByteSize",2,"uint8_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_SetAddressByteSize",1,SWIGTYPE_p_lldb__SBData);
}
arg2 = (uint8_t)lua_tointeger(L, 2);
(arg1)->SetAddressByteSize(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
SWIG_check_num_args("lldb::SBData::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::Clear",1,"lldb::SBData *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_Clear",1,SWIGTYPE_p_lldb__SBData);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBData::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::IsValid",1,"lldb::SBData *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_IsValid",1,SWIGTYPE_p_lldb__SBData);
}
result = (bool)(arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_GetByteSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBData::GetByteSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetByteSize",1,"lldb::SBData *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_GetByteSize",1,SWIGTYPE_p_lldb__SBData);
}
result = (arg1)->GetByteSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_GetByteOrder(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::ByteOrder result;
SWIG_check_num_args("lldb::SBData::GetByteOrder",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetByteOrder",1,"lldb::SBData *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_GetByteOrder",1,SWIGTYPE_p_lldb__SBData);
}
result = (lldb::ByteOrder)(arg1)->GetByteOrder();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_SetByteOrder(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::ByteOrder arg2 ;
SWIG_check_num_args("lldb::SBData::SetByteOrder",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetByteOrder",1,"lldb::SBData *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBData::SetByteOrder",2,"lldb::ByteOrder");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_SetByteOrder",1,SWIGTYPE_p_lldb__SBData);
}
arg2 = (lldb::ByteOrder)lua_tointeger(L, 2);
(arg1)->SetByteOrder(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_GetFloat(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::SBError *arg2 = 0 ;
lldb::offset_t arg3 ;
float result;
SWIG_check_num_args("lldb::SBData::GetFloat",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetFloat",1,"lldb::SBData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetFloat",2,"lldb::SBError &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetFloat",3,"lldb::offset_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_GetFloat",1,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBData_GetFloat",2,SWIGTYPE_p_lldb__SBError);
}
arg3 = (lldb::offset_t)lua_tointeger(L, 3);
result = (float)(arg1)->GetFloat(*arg2,arg3);
lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_GetDouble(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::SBError *arg2 = 0 ;
lldb::offset_t arg3 ;
double result;
SWIG_check_num_args("lldb::SBData::GetDouble",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetDouble",1,"lldb::SBData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetDouble",2,"lldb::SBError &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetDouble",3,"lldb::offset_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_GetDouble",1,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBData_GetDouble",2,SWIGTYPE_p_lldb__SBError);
}
arg3 = (lldb::offset_t)lua_tointeger(L, 3);
result = (double)(arg1)->GetDouble(*arg2,arg3);
lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_GetLongDouble(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::SBError *arg2 = 0 ;
lldb::offset_t arg3 ;
long double result;
SWIG_check_num_args("lldb::SBData::GetLongDouble",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetLongDouble",1,"lldb::SBData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetLongDouble",2,"lldb::SBError &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetLongDouble",3,"lldb::offset_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_GetLongDouble",1,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBData_GetLongDouble",2,SWIGTYPE_p_lldb__SBError);
}
arg3 = (lldb::offset_t)lua_tointeger(L, 3);
result = (long double)(arg1)->GetLongDouble(*arg2,arg3);
{
long double * resultptr = new long double((const long double &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_long_double,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_GetAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::SBError *arg2 = 0 ;
lldb::offset_t arg3 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBData::GetAddress",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetAddress",1,"lldb::SBData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetAddress",2,"lldb::SBError &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetAddress",3,"lldb::offset_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_GetAddress",1,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBData_GetAddress",2,SWIGTYPE_p_lldb__SBError);
}
arg3 = (lldb::offset_t)lua_tointeger(L, 3);
result = (lldb::addr_t)(arg1)->GetAddress(*arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_GetUnsignedInt8(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::SBError *arg2 = 0 ;
lldb::offset_t arg3 ;
uint8_t result;
SWIG_check_num_args("lldb::SBData::GetUnsignedInt8",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt8",1,"lldb::SBData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt8",2,"lldb::SBError &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt8",3,"lldb::offset_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_GetUnsignedInt8",1,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBData_GetUnsignedInt8",2,SWIGTYPE_p_lldb__SBError);
}
arg3 = (lldb::offset_t)lua_tointeger(L, 3);
result = (uint8_t)(arg1)->GetUnsignedInt8(*arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_GetUnsignedInt16(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::SBError *arg2 = 0 ;
lldb::offset_t arg3 ;
uint16_t result;
SWIG_check_num_args("lldb::SBData::GetUnsignedInt16",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt16",1,"lldb::SBData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt16",2,"lldb::SBError &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt16",3,"lldb::offset_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_GetUnsignedInt16",1,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBData_GetUnsignedInt16",2,SWIGTYPE_p_lldb__SBError);
}
arg3 = (lldb::offset_t)lua_tointeger(L, 3);
result = (uint16_t)(arg1)->GetUnsignedInt16(*arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_GetUnsignedInt32(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::SBError *arg2 = 0 ;
lldb::offset_t arg3 ;
uint32_t result;
SWIG_check_num_args("lldb::SBData::GetUnsignedInt32",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt32",1,"lldb::SBData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt32",2,"lldb::SBError &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt32",3,"lldb::offset_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_GetUnsignedInt32",1,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBData_GetUnsignedInt32",2,SWIGTYPE_p_lldb__SBError);
}
arg3 = (lldb::offset_t)lua_tointeger(L, 3);
result = (uint32_t)(arg1)->GetUnsignedInt32(*arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_GetUnsignedInt64(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::SBError *arg2 = 0 ;
lldb::offset_t arg3 ;
uint64_t result;
SWIG_check_num_args("lldb::SBData::GetUnsignedInt64",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt64",1,"lldb::SBData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt64",2,"lldb::SBError &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt64",3,"lldb::offset_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_GetUnsignedInt64",1,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBData_GetUnsignedInt64",2,SWIGTYPE_p_lldb__SBError);
}
arg3 = (lldb::offset_t)lua_tointeger(L, 3);
result = (uint64_t)(arg1)->GetUnsignedInt64(*arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_GetSignedInt8(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::SBError *arg2 = 0 ;
lldb::offset_t arg3 ;
int8_t result;
SWIG_check_num_args("lldb::SBData::GetSignedInt8",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetSignedInt8",1,"lldb::SBData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetSignedInt8",2,"lldb::SBError &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetSignedInt8",3,"lldb::offset_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_GetSignedInt8",1,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBData_GetSignedInt8",2,SWIGTYPE_p_lldb__SBError);
}
arg3 = (lldb::offset_t)lua_tointeger(L, 3);
result = (int8_t)(arg1)->GetSignedInt8(*arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_GetSignedInt16(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::SBError *arg2 = 0 ;
lldb::offset_t arg3 ;
int16_t result;
SWIG_check_num_args("lldb::SBData::GetSignedInt16",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetSignedInt16",1,"lldb::SBData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetSignedInt16",2,"lldb::SBError &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetSignedInt16",3,"lldb::offset_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_GetSignedInt16",1,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBData_GetSignedInt16",2,SWIGTYPE_p_lldb__SBError);
}
arg3 = (lldb::offset_t)lua_tointeger(L, 3);
result = (int16_t)(arg1)->GetSignedInt16(*arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_GetSignedInt32(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::SBError *arg2 = 0 ;
lldb::offset_t arg3 ;
int32_t result;
SWIG_check_num_args("lldb::SBData::GetSignedInt32",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetSignedInt32",1,"lldb::SBData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetSignedInt32",2,"lldb::SBError &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetSignedInt32",3,"lldb::offset_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_GetSignedInt32",1,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBData_GetSignedInt32",2,SWIGTYPE_p_lldb__SBError);
}
arg3 = (lldb::offset_t)lua_tointeger(L, 3);
result = (int32_t)(arg1)->GetSignedInt32(*arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_GetSignedInt64(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::SBError *arg2 = 0 ;
lldb::offset_t arg3 ;
int64_t result;
SWIG_check_num_args("lldb::SBData::GetSignedInt64",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetSignedInt64",1,"lldb::SBData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetSignedInt64",2,"lldb::SBError &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetSignedInt64",3,"lldb::offset_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_GetSignedInt64",1,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBData_GetSignedInt64",2,SWIGTYPE_p_lldb__SBError);
}
arg3 = (lldb::offset_t)lua_tointeger(L, 3);
result = (int64_t)(arg1)->GetSignedInt64(*arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_GetString(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::SBError *arg2 = 0 ;
lldb::offset_t arg3 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBData::GetString",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetString",1,"lldb::SBData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetString",2,"lldb::SBError &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetString",3,"lldb::offset_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_GetString",1,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBData_GetString",2,SWIGTYPE_p_lldb__SBError);
}
arg3 = (lldb::offset_t)lua_tointeger(L, 3);
result = (char *)(arg1)->GetString(*arg2,arg3);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::SBStream *arg2 = 0 ;
lldb::addr_t arg3 ;
bool result;
SWIG_check_num_args("lldb::SBData::GetDescription",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetDescription",1,"lldb::SBData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetDescription",2,"lldb::SBStream &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetDescription",3,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_GetDescription",1,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBData_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
arg3 = (lldb::addr_t)lua_tointeger(L, 3);
result = (bool)(arg1)->GetDescription(*arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_ReadRawData(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::SBError *arg2 = 0 ;
lldb::offset_t arg3 ;
void *arg4 = (void *) 0 ;
size_t arg5 ;
size_t result;
SWIG_check_num_args("lldb::SBData::ReadRawData",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::ReadRawData",1,"lldb::SBData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::ReadRawData",2,"lldb::SBError &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::ReadRawData",3,"lldb::offset_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_ReadRawData",1,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBData_ReadRawData",2,SWIGTYPE_p_lldb__SBError);
}
arg3 = (lldb::offset_t)lua_tointeger(L, 3);
{
arg5 = luaL_checkinteger(L, 4);
if (arg5 <= 0) {
return luaL_error(L, "Positive integer expected");
}
arg4 = (char *)malloc(arg5);
}
result = (arg1)->ReadRawData(*arg2,arg3,arg4,arg5);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
{
lua_pop(L, 1); // Blow away the previous result
if (result == 0) {
lua_pushliteral(L, "");
} else {
lua_pushlstring(L, (const char *)arg4, result);
}
free(arg4);
// SWIG_arg was already incremented
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_SetData(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::SBError *arg2 = 0 ;
void *arg3 = (void *) 0 ;
size_t arg4 ;
lldb::ByteOrder arg5 ;
uint8_t arg6 ;
SWIG_check_num_args("lldb::SBData::SetData",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetData",1,"lldb::SBData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::SetData",2,"lldb::SBError &");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBData::SetData",4,"lldb::ByteOrder");
if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBData::SetData",5,"uint8_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_SetData",1,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBData_SetData",2,SWIGTYPE_p_lldb__SBError);
}
{
arg3 = (void *)luaL_checklstring(L, 3, &arg4);
}
arg5 = (lldb::ByteOrder)lua_tointeger(L, 4);
arg6 = (uint8_t)lua_tointeger(L, 5);
(arg1)->SetData(*arg2,(void const *)arg3,arg4,arg5,arg6);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_SetDataWithOwnership(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::SBError *arg2 = 0 ;
void *arg3 = (void *) 0 ;
size_t arg4 ;
lldb::ByteOrder arg5 ;
uint8_t arg6 ;
SWIG_check_num_args("lldb::SBData::SetDataWithOwnership",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetDataWithOwnership",1,"lldb::SBData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::SetDataWithOwnership",2,"lldb::SBError &");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBData::SetDataWithOwnership",4,"lldb::ByteOrder");
if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBData::SetDataWithOwnership",5,"uint8_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_SetDataWithOwnership",1,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBData_SetDataWithOwnership",2,SWIGTYPE_p_lldb__SBError);
}
{
arg3 = (void *)luaL_checklstring(L, 3, &arg4);
}
arg5 = (lldb::ByteOrder)lua_tointeger(L, 4);
arg6 = (uint8_t)lua_tointeger(L, 5);
(arg1)->SetDataWithOwnership(*arg2,(void const *)arg3,arg4,arg5,arg6);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_Append(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
lldb::SBData *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBData::Append",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::Append",1,"lldb::SBData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::Append",2,"lldb::SBData const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_Append",1,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_Append",2,SWIGTYPE_p_lldb__SBData);
}
result = (bool)(arg1)->Append((lldb::SBData const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_CreateDataFromCString(lua_State* L) {
int SWIG_arg = 0;
lldb::ByteOrder arg1 ;
uint32_t arg2 ;
char *arg3 = (char *) 0 ;
lldb::SBData result;
SWIG_check_num_args("lldb::SBData::CreateDataFromCString",3,3)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBData::CreateDataFromCString",1,"lldb::ByteOrder");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBData::CreateDataFromCString",2,"uint32_t");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBData::CreateDataFromCString",3,"char const *");
arg1 = (lldb::ByteOrder)lua_tointeger(L, 1);
arg2 = (uint32_t)lua_tointeger(L, 2);
arg3 = (char *)lua_tostring(L, 3);
result = lldb::SBData::CreateDataFromCString(arg1,arg2,(char const *)arg3);
{
lldb::SBData * resultptr = new lldb::SBData((const lldb::SBData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_CreateDataFromUInt64Array(lua_State* L) {
int SWIG_arg = 0;
lldb::ByteOrder arg1 ;
uint32_t arg2 ;
uint64_t *arg3 = (uint64_t *) 0 ;
size_t arg4 ;
lldb::SBData result;
SWIG_check_num_args("lldb::SBData::CreateDataFromUInt64Array",3,3)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBData::CreateDataFromUInt64Array",1,"lldb::ByteOrder");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBData::CreateDataFromUInt64Array",2,"uint32_t");
arg1 = (lldb::ByteOrder)lua_tointeger(L, 1);
arg2 = (uint32_t)lua_tointeger(L, 2);
{
if (lua_istable(L, 3)) {
// It should accept a table of numbers.
arg4 = lua_rawlen(L, 3);
arg3 = (uint64_t *)malloc((arg4) * sizeof(uint64_t));
int i = 0, j = 0;
while (i++ < arg4) {
lua_rawgeti(L, 3, i);
if (!lua_isnumber(L, -1)) {
// if current element cannot be converted to number, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain numbers");
}
arg3[j++] = (uint64_t) lua_tonumber(L, -1);
lua_pop(L, 1);
}
} else if (lua_isnil(L, 3)) {
// "nil" is also acceptable, equivalent as an empty table
arg3 = NULL;
arg4 = 0;
} else {
// else raise an error
return luaL_error(L, "A list of numbers expected.");
}
}
result = lldb::SBData::CreateDataFromUInt64Array(arg1,arg2,arg3,arg4);
{
lldb::SBData * resultptr = new lldb::SBData((const lldb::SBData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++;
}
{
free(arg3);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free(arg3);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_CreateDataFromUInt32Array(lua_State* L) {
int SWIG_arg = 0;
lldb::ByteOrder arg1 ;
uint32_t arg2 ;
uint32_t *arg3 = (uint32_t *) 0 ;
size_t arg4 ;
lldb::SBData result;
SWIG_check_num_args("lldb::SBData::CreateDataFromUInt32Array",3,3)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBData::CreateDataFromUInt32Array",1,"lldb::ByteOrder");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBData::CreateDataFromUInt32Array",2,"uint32_t");
arg1 = (lldb::ByteOrder)lua_tointeger(L, 1);
arg2 = (uint32_t)lua_tointeger(L, 2);
{
if (lua_istable(L, 3)) {
// It should accept a table of numbers.
arg4 = lua_rawlen(L, 3);
arg3 = (uint32_t *)malloc((arg4) * sizeof(uint32_t));
int i = 0, j = 0;
while (i++ < arg4) {
lua_rawgeti(L, 3, i);
if (!lua_isnumber(L, -1)) {
// if current element cannot be converted to number, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain numbers");
}
arg3[j++] = (uint32_t) lua_tonumber(L, -1);
lua_pop(L, 1);
}
} else if (lua_isnil(L, 3)) {
// "nil" is also acceptable, equivalent as an empty table
arg3 = NULL;
arg4 = 0;
} else {
// else raise an error
return luaL_error(L, "A list of numbers expected.");
}
}
result = lldb::SBData::CreateDataFromUInt32Array(arg1,arg2,arg3,arg4);
{
lldb::SBData * resultptr = new lldb::SBData((const lldb::SBData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++;
}
{
free(arg3);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free(arg3);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_CreateDataFromSInt64Array(lua_State* L) {
int SWIG_arg = 0;
lldb::ByteOrder arg1 ;
uint32_t arg2 ;
int64_t *arg3 = (int64_t *) 0 ;
size_t arg4 ;
lldb::SBData result;
SWIG_check_num_args("lldb::SBData::CreateDataFromSInt64Array",3,3)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBData::CreateDataFromSInt64Array",1,"lldb::ByteOrder");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBData::CreateDataFromSInt64Array",2,"uint32_t");
arg1 = (lldb::ByteOrder)lua_tointeger(L, 1);
arg2 = (uint32_t)lua_tointeger(L, 2);
{
if (lua_istable(L, 3)) {
// It should accept a table of numbers.
arg4 = lua_rawlen(L, 3);
arg3 = (int64_t *)malloc((arg4) * sizeof(int64_t));
int i = 0, j = 0;
while (i++ < arg4) {
lua_rawgeti(L, 3, i);
if (!lua_isnumber(L, -1)) {
// if current element cannot be converted to number, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain numbers");
}
arg3[j++] = (int64_t) lua_tonumber(L, -1);
lua_pop(L, 1);
}
} else if (lua_isnil(L, 3)) {
// "nil" is also acceptable, equivalent as an empty table
arg3 = NULL;
arg4 = 0;
} else {
// else raise an error
return luaL_error(L, "A list of numbers expected.");
}
}
result = lldb::SBData::CreateDataFromSInt64Array(arg1,arg2,arg3,arg4);
{
lldb::SBData * resultptr = new lldb::SBData((const lldb::SBData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++;
}
{
free(arg3);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free(arg3);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_CreateDataFromSInt32Array(lua_State* L) {
int SWIG_arg = 0;
lldb::ByteOrder arg1 ;
uint32_t arg2 ;
int32_t *arg3 = (int32_t *) 0 ;
size_t arg4 ;
lldb::SBData result;
SWIG_check_num_args("lldb::SBData::CreateDataFromSInt32Array",3,3)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBData::CreateDataFromSInt32Array",1,"lldb::ByteOrder");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBData::CreateDataFromSInt32Array",2,"uint32_t");
arg1 = (lldb::ByteOrder)lua_tointeger(L, 1);
arg2 = (uint32_t)lua_tointeger(L, 2);
{
if (lua_istable(L, 3)) {
// It should accept a table of numbers.
arg4 = lua_rawlen(L, 3);
arg3 = (int32_t *)malloc((arg4) * sizeof(int32_t));
int i = 0, j = 0;
while (i++ < arg4) {
lua_rawgeti(L, 3, i);
if (!lua_isnumber(L, -1)) {
// if current element cannot be converted to number, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain numbers");
}
arg3[j++] = (int32_t) lua_tonumber(L, -1);
lua_pop(L, 1);
}
} else if (lua_isnil(L, 3)) {
// "nil" is also acceptable, equivalent as an empty table
arg3 = NULL;
arg4 = 0;
} else {
// else raise an error
return luaL_error(L, "A list of numbers expected.");
}
}
result = lldb::SBData::CreateDataFromSInt32Array(arg1,arg2,arg3,arg4);
{
lldb::SBData * resultptr = new lldb::SBData((const lldb::SBData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++;
}
{
free(arg3);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free(arg3);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_CreateDataFromDoubleArray(lua_State* L) {
int SWIG_arg = 0;
lldb::ByteOrder arg1 ;
uint32_t arg2 ;
double *arg3 = (double *) 0 ;
size_t arg4 ;
lldb::SBData result;
SWIG_check_num_args("lldb::SBData::CreateDataFromDoubleArray",3,3)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBData::CreateDataFromDoubleArray",1,"lldb::ByteOrder");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBData::CreateDataFromDoubleArray",2,"uint32_t");
arg1 = (lldb::ByteOrder)lua_tointeger(L, 1);
arg2 = (uint32_t)lua_tointeger(L, 2);
{
if (lua_istable(L, 3)) {
// It should accept a table of numbers.
arg4 = lua_rawlen(L, 3);
arg3 = (double *)malloc((arg4) * sizeof(double));
int i = 0, j = 0;
while (i++ < arg4) {
lua_rawgeti(L, 3, i);
if (!lua_isnumber(L, -1)) {
// if current element cannot be converted to number, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain numbers");
}
arg3[j++] = (double) lua_tonumber(L, -1);
lua_pop(L, 1);
}
} else if (lua_isnil(L, 3)) {
// "nil" is also acceptable, equivalent as an empty table
arg3 = NULL;
arg4 = 0;
} else {
// else raise an error
return luaL_error(L, "A list of numbers expected.");
}
}
result = lldb::SBData::CreateDataFromDoubleArray(arg1,arg2,arg3,arg4);
{
lldb::SBData * resultptr = new lldb::SBData((const lldb::SBData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++;
}
{
free(arg3);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free(arg3);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_SetDataFromCString(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
char *arg2 = (char *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBData::SetDataFromCString",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetDataFromCString",1,"lldb::SBData *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBData::SetDataFromCString",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_SetDataFromCString",1,SWIGTYPE_p_lldb__SBData);
}
arg2 = (char *)lua_tostring(L, 2);
result = (bool)(arg1)->SetDataFromCString((char const *)arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_SetDataFromUInt64Array(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
uint64_t *arg2 = (uint64_t *) 0 ;
size_t arg3 ;
bool result;
SWIG_check_num_args("lldb::SBData::SetDataFromUInt64Array",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetDataFromUInt64Array",1,"lldb::SBData *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_SetDataFromUInt64Array",1,SWIGTYPE_p_lldb__SBData);
}
{
if (lua_istable(L, 2)) {
// It should accept a table of numbers.
arg3 = lua_rawlen(L, 2);
arg2 = (uint64_t *)malloc((arg3) * sizeof(uint64_t));
int i = 0, j = 0;
while (i++ < arg3) {
lua_rawgeti(L, 2, i);
if (!lua_isnumber(L, -1)) {
// if current element cannot be converted to number, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain numbers");
}
arg2[j++] = (uint64_t) lua_tonumber(L, -1);
lua_pop(L, 1);
}
} else if (lua_isnil(L, 2)) {
// "nil" is also acceptable, equivalent as an empty table
arg2 = NULL;
arg3 = 0;
} else {
// else raise an error
return luaL_error(L, "A list of numbers expected.");
}
}
result = (bool)(arg1)->SetDataFromUInt64Array(arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
{
free(arg2);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free(arg2);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_SetDataFromUInt32Array(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
uint32_t *arg2 = (uint32_t *) 0 ;
size_t arg3 ;
bool result;
SWIG_check_num_args("lldb::SBData::SetDataFromUInt32Array",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetDataFromUInt32Array",1,"lldb::SBData *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_SetDataFromUInt32Array",1,SWIGTYPE_p_lldb__SBData);
}
{
if (lua_istable(L, 2)) {
// It should accept a table of numbers.
arg3 = lua_rawlen(L, 2);
arg2 = (uint32_t *)malloc((arg3) * sizeof(uint32_t));
int i = 0, j = 0;
while (i++ < arg3) {
lua_rawgeti(L, 2, i);
if (!lua_isnumber(L, -1)) {
// if current element cannot be converted to number, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain numbers");
}
arg2[j++] = (uint32_t) lua_tonumber(L, -1);
lua_pop(L, 1);
}
} else if (lua_isnil(L, 2)) {
// "nil" is also acceptable, equivalent as an empty table
arg2 = NULL;
arg3 = 0;
} else {
// else raise an error
return luaL_error(L, "A list of numbers expected.");
}
}
result = (bool)(arg1)->SetDataFromUInt32Array(arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
{
free(arg2);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free(arg2);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_SetDataFromSInt64Array(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
int64_t *arg2 = (int64_t *) 0 ;
size_t arg3 ;
bool result;
SWIG_check_num_args("lldb::SBData::SetDataFromSInt64Array",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetDataFromSInt64Array",1,"lldb::SBData *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_SetDataFromSInt64Array",1,SWIGTYPE_p_lldb__SBData);
}
{
if (lua_istable(L, 2)) {
// It should accept a table of numbers.
arg3 = lua_rawlen(L, 2);
arg2 = (int64_t *)malloc((arg3) * sizeof(int64_t));
int i = 0, j = 0;
while (i++ < arg3) {
lua_rawgeti(L, 2, i);
if (!lua_isnumber(L, -1)) {
// if current element cannot be converted to number, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain numbers");
}
arg2[j++] = (int64_t) lua_tonumber(L, -1);
lua_pop(L, 1);
}
} else if (lua_isnil(L, 2)) {
// "nil" is also acceptable, equivalent as an empty table
arg2 = NULL;
arg3 = 0;
} else {
// else raise an error
return luaL_error(L, "A list of numbers expected.");
}
}
result = (bool)(arg1)->SetDataFromSInt64Array(arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
{
free(arg2);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free(arg2);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_SetDataFromSInt32Array(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
int32_t *arg2 = (int32_t *) 0 ;
size_t arg3 ;
bool result;
SWIG_check_num_args("lldb::SBData::SetDataFromSInt32Array",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetDataFromSInt32Array",1,"lldb::SBData *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_SetDataFromSInt32Array",1,SWIGTYPE_p_lldb__SBData);
}
{
if (lua_istable(L, 2)) {
// It should accept a table of numbers.
arg3 = lua_rawlen(L, 2);
arg2 = (int32_t *)malloc((arg3) * sizeof(int32_t));
int i = 0, j = 0;
while (i++ < arg3) {
lua_rawgeti(L, 2, i);
if (!lua_isnumber(L, -1)) {
// if current element cannot be converted to number, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain numbers");
}
arg2[j++] = (int32_t) lua_tonumber(L, -1);
lua_pop(L, 1);
}
} else if (lua_isnil(L, 2)) {
// "nil" is also acceptable, equivalent as an empty table
arg2 = NULL;
arg3 = 0;
} else {
// else raise an error
return luaL_error(L, "A list of numbers expected.");
}
}
result = (bool)(arg1)->SetDataFromSInt32Array(arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
{
free(arg2);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free(arg2);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData_SetDataFromDoubleArray(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
double *arg2 = (double *) 0 ;
size_t arg3 ;
bool result;
SWIG_check_num_args("lldb::SBData::SetDataFromDoubleArray",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetDataFromDoubleArray",1,"lldb::SBData *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData_SetDataFromDoubleArray",1,SWIGTYPE_p_lldb__SBData);
}
{
if (lua_istable(L, 2)) {
// It should accept a table of numbers.
arg3 = lua_rawlen(L, 2);
arg2 = (double *)malloc((arg3) * sizeof(double));
int i = 0, j = 0;
while (i++ < arg3) {
lua_rawgeti(L, 2, i);
if (!lua_isnumber(L, -1)) {
// if current element cannot be converted to number, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain numbers");
}
arg2[j++] = (double) lua_tonumber(L, -1);
lua_pop(L, 1);
}
} else if (lua_isnil(L, 2)) {
// "nil" is also acceptable, equivalent as an empty table
arg2 = NULL;
arg3 = 0;
} else {
// else raise an error
return luaL_error(L, "A list of numbers expected.");
}
}
result = (bool)(arg1)->SetDataFromDoubleArray(arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
{
free(arg2);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free(arg2);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBData___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBData *arg1 = (lldb::SBData *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBData::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::__str__",1,"lldb::SBData *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBData___tostring",1,SWIGTYPE_p_lldb__SBData);
}
result = lldb_SBData___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBData(void *obj) {
lldb::SBData *arg1 = (lldb::SBData *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBData(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBData);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBData_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBData_methods[]= {
{ "GetAddressByteSize", _wrap_SBData_GetAddressByteSize},
{ "SetAddressByteSize", _wrap_SBData_SetAddressByteSize},
{ "Clear", _wrap_SBData_Clear},
{ "IsValid", _wrap_SBData_IsValid},
{ "GetByteSize", _wrap_SBData_GetByteSize},
{ "GetByteOrder", _wrap_SBData_GetByteOrder},
{ "SetByteOrder", _wrap_SBData_SetByteOrder},
{ "GetFloat", _wrap_SBData_GetFloat},
{ "GetDouble", _wrap_SBData_GetDouble},
{ "GetLongDouble", _wrap_SBData_GetLongDouble},
{ "GetAddress", _wrap_SBData_GetAddress},
{ "GetUnsignedInt8", _wrap_SBData_GetUnsignedInt8},
{ "GetUnsignedInt16", _wrap_SBData_GetUnsignedInt16},
{ "GetUnsignedInt32", _wrap_SBData_GetUnsignedInt32},
{ "GetUnsignedInt64", _wrap_SBData_GetUnsignedInt64},
{ "GetSignedInt8", _wrap_SBData_GetSignedInt8},
{ "GetSignedInt16", _wrap_SBData_GetSignedInt16},
{ "GetSignedInt32", _wrap_SBData_GetSignedInt32},
{ "GetSignedInt64", _wrap_SBData_GetSignedInt64},
{ "GetString", _wrap_SBData_GetString},
{ "GetDescription", _wrap_SBData_GetDescription},
{ "ReadRawData", _wrap_SBData_ReadRawData},
{ "SetData", _wrap_SBData_SetData},
{ "SetDataWithOwnership", _wrap_SBData_SetDataWithOwnership},
{ "Append", _wrap_SBData_Append},
{ "SetDataFromCString", _wrap_SBData_SetDataFromCString},
{ "SetDataFromUInt64Array", _wrap_SBData_SetDataFromUInt64Array},
{ "SetDataFromUInt32Array", _wrap_SBData_SetDataFromUInt32Array},
{ "SetDataFromSInt64Array", _wrap_SBData_SetDataFromSInt64Array},
{ "SetDataFromSInt32Array", _wrap_SBData_SetDataFromSInt32Array},
{ "SetDataFromDoubleArray", _wrap_SBData_SetDataFromDoubleArray},
{ "__tostring", _wrap_SBData___tostring},
{0,0}
};
static swig_lua_method swig_SBData_meta[] = {
{ "__tostring", _wrap_SBData___tostring},
{0,0}
};
static swig_lua_attribute swig_SBData_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBData_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBData_Sf_SwigStatic_methods[]= {
{ "CreateDataFromCString", _wrap_SBData_CreateDataFromCString},
{ "CreateDataFromUInt64Array", _wrap_SBData_CreateDataFromUInt64Array},
{ "CreateDataFromUInt32Array", _wrap_SBData_CreateDataFromUInt32Array},
{ "CreateDataFromSInt64Array", _wrap_SBData_CreateDataFromSInt64Array},
{ "CreateDataFromSInt32Array", _wrap_SBData_CreateDataFromSInt32Array},
{ "CreateDataFromDoubleArray", _wrap_SBData_CreateDataFromDoubleArray},
{0,0}
};
static swig_lua_class* swig_SBData_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBData_Sf_SwigStatic = {
"SBData",
swig_SBData_Sf_SwigStatic_methods,
swig_SBData_Sf_SwigStatic_attributes,
swig_SBData_Sf_SwigStatic_constants,
swig_SBData_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBData_bases[] = {0};
static const char *swig_SBData_base_names[] = {0};
static swig_lua_class _wrap_class_SBData = { "SBData", "SBData", &SWIGTYPE_p_lldb__SBData,_proxy__wrap_new_SBData, swig_delete_SBData, swig_SBData_methods, swig_SBData_attributes, &swig_SBData_Sf_SwigStatic, swig_SBData_meta, swig_SBData_bases, swig_SBData_base_names };
static int _wrap_SBDebugger_Initialize(lua_State* L) {
int SWIG_arg = 0;
SWIG_check_num_args("lldb::SBDebugger::Initialize",0,0)
lldb::SBDebugger::Initialize();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_InitializeWithErrorHandling(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError result;
SWIG_check_num_args("lldb::SBDebugger::InitializeWithErrorHandling",0,0)
result = lldb::SBDebugger::InitializeWithErrorHandling();
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_Terminate(lua_State* L) {
int SWIG_arg = 0;
SWIG_check_num_args("lldb::SBDebugger::Terminate",0,0)
lldb::SBDebugger::Terminate();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_Create__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger result;
SWIG_check_num_args("lldb::SBDebugger::Create",0,0)
result = lldb::SBDebugger::Create();
{
lldb::SBDebugger * resultptr = new lldb::SBDebugger((const lldb::SBDebugger &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBDebugger,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_Create__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
bool arg1 ;
lldb::SBDebugger result;
SWIG_check_num_args("lldb::SBDebugger::Create",1,1)
if(!lua_isboolean(L,1)) SWIG_fail_arg("lldb::SBDebugger::Create",1,"bool");
arg1 = (lua_toboolean(L, 1)!=0);
result = lldb::SBDebugger::Create(arg1);
{
lldb::SBDebugger * resultptr = new lldb::SBDebugger((const lldb::SBDebugger &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBDebugger,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_Create__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
bool arg1 ;
lldb::LogOutputCallback arg2 = (lldb::LogOutputCallback) 0 ;
void *arg3 = (void *) 0 ;
lldb::SBDebugger result;
SWIG_check_num_args("lldb::SBDebugger::Create",2,2)
if(!lua_isboolean(L,1)) SWIG_fail_arg("lldb::SBDebugger::Create",1,"bool");
arg1 = (lua_toboolean(L, 1)!=0);
{
arg2 = LLDBSwigLuaCallLuaLogOutputCallback;
arg3 = (void *)L;
luaL_checktype(L, 2, LUA_TFUNCTION);
lua_settop(L, 2);
lua_pushlightuserdata(L, (void *)&LLDBSwigLuaCallLuaLogOutputCallback);
lua_insert(L, 2);
lua_settable(L, LUA_REGISTRYINDEX);
}
result = lldb::SBDebugger::Create(arg1,arg2,arg3);
{
lldb::SBDebugger * resultptr = new lldb::SBDebugger((const lldb::SBDebugger &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBDebugger,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_Create(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_SBDebugger_Create__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
_v = lua_isboolean(L,argv[0]);
}
if (_v) {
return _wrap_SBDebugger_Create__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
_v = lua_isboolean(L,argv[0]);
}
if (_v) {
{
void *ptr;
if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_f_p_q_const__char_p_void__void, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
if (argc <= 2) {
return _wrap_SBDebugger_Create__SWIG_2(L);
}
{
void *ptr;
if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, 0, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBDebugger_Create__SWIG_2(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBDebugger_Create'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBDebugger::Create()\n"
" lldb::SBDebugger::Create(bool)\n"
" lldb::SBDebugger::Create(bool,lldb::LogOutputCallback,void *)\n");
lua_error(L);return 0;
}
static int _wrap_SBDebugger_Destroy(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = 0 ;
SWIG_check_num_args("lldb::SBDebugger::Destroy",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBDebugger::Destroy",1,"lldb::SBDebugger &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_Destroy",1,SWIGTYPE_p_lldb__SBDebugger);
}
lldb::SBDebugger::Destroy(*arg1);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_MemoryPressureDetected(lua_State* L) {
int SWIG_arg = 0;
SWIG_check_num_args("lldb::SBDebugger::MemoryPressureDetected",0,0)
lldb::SBDebugger::MemoryPressureDetected();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBDebugger__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *result = 0 ;
SWIG_check_num_args("lldb::SBDebugger::SBDebugger",0,0)
result = (lldb::SBDebugger *)new lldb::SBDebugger();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBDebugger,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBDebugger__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = 0 ;
lldb::SBDebugger *result = 0 ;
SWIG_check_num_args("lldb::SBDebugger::SBDebugger",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBDebugger::SBDebugger",1,"lldb::SBDebugger const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("new_SBDebugger",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (lldb::SBDebugger *)new lldb::SBDebugger((lldb::SBDebugger const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBDebugger,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBDebugger(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBDebugger__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBDebugger__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBDebugger'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBDebugger::SBDebugger()\n"
" lldb::SBDebugger::SBDebugger(lldb::SBDebugger const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBDebugger_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBDebugger::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::IsValid",1,"lldb::SBDebugger const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_IsValid",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (bool)((lldb::SBDebugger const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
SWIG_check_num_args("lldb::SBDebugger::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::Clear",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_Clear",1,SWIGTYPE_p_lldb__SBDebugger);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetAsync(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBDebugger::SetAsync",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetAsync",1,"lldb::SBDebugger *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetAsync",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetAsync",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetAsync(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetAsync(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBDebugger::GetAsync",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetAsync",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetAsync",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (bool)(arg1)->GetAsync();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SkipLLDBInitFiles(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBDebugger::SkipLLDBInitFiles",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SkipLLDBInitFiles",1,"lldb::SBDebugger *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBDebugger::SkipLLDBInitFiles",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SkipLLDBInitFiles",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SkipLLDBInitFiles(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetInputFileHandle(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > result;
SWIG_check_num_args("lldb::SBDebugger::GetInputFileHandle",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetInputFileHandle",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetInputFileHandle",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = lldb_SBDebugger_GetInputFileHandle(arg1);
{
lldb::FileSP &sp = result;
if (sp && sp->IsValid()) {
luaL_Stream *p = (luaL_Stream *)lua_newuserdata(L, sizeof(luaL_Stream));
p->closef = &LLDBSwigLuaCloseFileHandle;
p->f = sp->GetStream();
luaL_setmetatable(L, LUA_FILEHANDLE);
SWIG_arg++;
}
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetOutputFileHandle(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > result;
SWIG_check_num_args("lldb::SBDebugger::GetOutputFileHandle",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetOutputFileHandle",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetOutputFileHandle",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = lldb_SBDebugger_GetOutputFileHandle(arg1);
{
lldb::FileSP &sp = result;
if (sp && sp->IsValid()) {
luaL_Stream *p = (luaL_Stream *)lua_newuserdata(L, sizeof(luaL_Stream));
p->closef = &LLDBSwigLuaCloseFileHandle;
p->f = sp->GetStream();
luaL_setmetatable(L, LUA_FILEHANDLE);
SWIG_arg++;
}
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetErrorFileHandle(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > result;
SWIG_check_num_args("lldb::SBDebugger::GetErrorFileHandle",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetErrorFileHandle",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetErrorFileHandle",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = lldb_SBDebugger_GetErrorFileHandle(arg1);
{
lldb::FileSP &sp = result;
if (sp && sp->IsValid()) {
luaL_Stream *p = (luaL_Stream *)lua_newuserdata(L, sizeof(luaL_Stream));
p->closef = &LLDBSwigLuaCloseFileHandle;
p->f = sp->GetStream();
luaL_setmetatable(L, LUA_FILEHANDLE);
SWIG_arg++;
}
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetInputString(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBDebugger::SetInputString",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetInputString",1,"lldb::SBDebugger *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetInputString",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetInputString",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->SetInputString((char const *)arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetInputFile__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBFile arg2 ;
lldb::SBFile *argp2 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBDebugger::SetInputFile",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetInputFile",1,"lldb::SBDebugger *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetInputFile",2,"lldb::SBFile");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetInputFile",1,SWIGTYPE_p_lldb__SBDebugger);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBDebugger_SetInputFile",2,SWIGTYPE_p_lldb__SBFile);
}
arg2 = *argp2;
result = (arg1)->SetInputFile(arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetOutputFile__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBFile arg2 ;
lldb::SBFile *argp2 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBDebugger::SetOutputFile",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetOutputFile",1,"lldb::SBDebugger *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetOutputFile",2,"lldb::SBFile");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetOutputFile",1,SWIGTYPE_p_lldb__SBDebugger);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBDebugger_SetOutputFile",2,SWIGTYPE_p_lldb__SBFile);
}
arg2 = *argp2;
result = (arg1)->SetOutputFile(arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetErrorFile__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBFile arg2 ;
lldb::SBFile *argp2 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBDebugger::SetErrorFile",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetErrorFile",1,"lldb::SBDebugger *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetErrorFile",2,"lldb::SBFile");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetErrorFile",1,SWIGTYPE_p_lldb__SBDebugger);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBDebugger_SetErrorFile",2,SWIGTYPE_p_lldb__SBFile);
}
arg2 = *argp2;
result = (arg1)->SetErrorFile(arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetInputFile__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBDebugger::SetInputFile",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetInputFile",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetInputFile",1,SWIGTYPE_p_lldb__SBDebugger);
}
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg2 = file_sp;
}
result = (arg1)->SetInputFile(arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetInputFile(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBDebugger_SetInputFile__SWIG_0(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_isuserdata(L, argv[1])) &&
(luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr);
}
if (_v) {
return _wrap_SBDebugger_SetInputFile__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBDebugger_SetInputFile'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBDebugger::SetInputFile(lldb::SBFile)\n"
" lldb::SBDebugger::SetInputFile(lldb::FileSP)\n");
lua_error(L);return 0;
}
static int _wrap_SBDebugger_SetOutputFile__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBDebugger::SetOutputFile",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetOutputFile",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetOutputFile",1,SWIGTYPE_p_lldb__SBDebugger);
}
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg2 = file_sp;
}
result = (arg1)->SetOutputFile(arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetOutputFile(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBDebugger_SetOutputFile__SWIG_0(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_isuserdata(L, argv[1])) &&
(luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr);
}
if (_v) {
return _wrap_SBDebugger_SetOutputFile__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBDebugger_SetOutputFile'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBDebugger::SetOutputFile(lldb::SBFile)\n"
" lldb::SBDebugger::SetOutputFile(lldb::FileSP)\n");
lua_error(L);return 0;
}
static int _wrap_SBDebugger_SetErrorFile__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBDebugger::SetErrorFile",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetErrorFile",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetErrorFile",1,SWIGTYPE_p_lldb__SBDebugger);
}
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg2 = file_sp;
}
result = (arg1)->SetErrorFile(arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetErrorFile(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBDebugger_SetErrorFile__SWIG_0(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_isuserdata(L, argv[1])) &&
(luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr);
}
if (_v) {
return _wrap_SBDebugger_SetErrorFile__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBDebugger_SetErrorFile'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBDebugger::SetErrorFile(lldb::SBFile)\n"
" lldb::SBDebugger::SetErrorFile(lldb::FileSP)\n");
lua_error(L);return 0;
}
static int _wrap_SBDebugger_GetInputFile(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBFile result;
SWIG_check_num_args("lldb::SBDebugger::GetInputFile",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetInputFile",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetInputFile",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (arg1)->GetInputFile();
{
lldb::SBFile * resultptr = new lldb::SBFile((const lldb::SBFile &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFile,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetOutputFile(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBFile result;
SWIG_check_num_args("lldb::SBDebugger::GetOutputFile",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetOutputFile",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetOutputFile",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (arg1)->GetOutputFile();
{
lldb::SBFile * resultptr = new lldb::SBFile((const lldb::SBFile &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFile,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetErrorFile(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBFile result;
SWIG_check_num_args("lldb::SBDebugger::GetErrorFile",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetErrorFile",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetErrorFile",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (arg1)->GetErrorFile();
{
lldb::SBFile * resultptr = new lldb::SBFile((const lldb::SBFile &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFile,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetCommandInterpreter(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
SwigValueWrapper< lldb::SBCommandInterpreter > result;
SWIG_check_num_args("lldb::SBDebugger::GetCommandInterpreter",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetCommandInterpreter",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetCommandInterpreter",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (arg1)->GetCommandInterpreter();
{
lldb::SBCommandInterpreter * resultptr = new lldb::SBCommandInterpreter((const lldb::SBCommandInterpreter &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBCommandInterpreter,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_HandleCommand(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBDebugger::HandleCommand",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::HandleCommand",1,"lldb::SBDebugger *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::HandleCommand",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_HandleCommand",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->HandleCommand((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetListener(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBListener result;
SWIG_check_num_args("lldb::SBDebugger::GetListener",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetListener",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetListener",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (arg1)->GetListener();
{
lldb::SBListener * resultptr = new lldb::SBListener((const lldb::SBListener &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBListener,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_HandleProcessEvent__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBProcess *arg2 = 0 ;
lldb::SBEvent *arg3 = 0 ;
lldb::SBFile arg4 ;
lldb::SBFile arg5 ;
lldb::SBFile *argp4 ;
lldb::SBFile *argp5 ;
SWIG_check_num_args("lldb::SBDebugger::HandleProcessEvent",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::HandleProcessEvent",1,"lldb::SBDebugger *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::HandleProcessEvent",2,"lldb::SBProcess const &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBDebugger::HandleProcessEvent",3,"lldb::SBEvent const &");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBDebugger::HandleProcessEvent",4,"lldb::SBFile");
if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBDebugger::HandleProcessEvent",5,"lldb::SBFile");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_HandleProcessEvent",1,SWIGTYPE_p_lldb__SBDebugger);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBDebugger_HandleProcessEvent",2,SWIGTYPE_p_lldb__SBProcess);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBDebugger_HandleProcessEvent",3,SWIGTYPE_p_lldb__SBEvent);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBDebugger_HandleProcessEvent",4,SWIGTYPE_p_lldb__SBFile);
}
arg4 = *argp4;
if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&argp5,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBDebugger_HandleProcessEvent",5,SWIGTYPE_p_lldb__SBFile);
}
arg5 = *argp5;
(arg1)->HandleProcessEvent((lldb::SBProcess const &)*arg2,(lldb::SBEvent const &)*arg3,arg4,arg5);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_HandleProcessEvent__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBProcess *arg2 = 0 ;
lldb::SBEvent *arg3 = 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg4 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg5 ;
SWIG_check_num_args("lldb::SBDebugger::HandleProcessEvent",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::HandleProcessEvent",1,"lldb::SBDebugger *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::HandleProcessEvent",2,"lldb::SBProcess const &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBDebugger::HandleProcessEvent",3,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_HandleProcessEvent",1,SWIGTYPE_p_lldb__SBDebugger);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBDebugger_HandleProcessEvent",2,SWIGTYPE_p_lldb__SBProcess);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBDebugger_HandleProcessEvent",3,SWIGTYPE_p_lldb__SBEvent);
}
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 4, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg4 = file_sp;
}
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 5, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg5 = file_sp;
}
(arg1)->HandleProcessEvent((lldb::SBProcess const &)*arg2,(lldb::SBEvent const &)*arg3,arg4,arg5);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_HandleProcessEvent(lua_State* L) {
int argc;
int argv[6]={
1,2,3,4,5,6
};
argc = lua_gettop(L);
if (argc == 5) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBDebugger_HandleProcessEvent__SWIG_0(L);
}
}
}
}
}
}
if (argc == 5) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_isuserdata(L, argv[3])) &&
(luaL_testudata(L, argv[3], LUA_FILEHANDLE) != nullptr);
}
if (_v) {
{
_v = (lua_isuserdata(L, argv[4])) &&
(luaL_testudata(L, argv[4], LUA_FILEHANDLE) != nullptr);
}
if (_v) {
return _wrap_SBDebugger_HandleProcessEvent__SWIG_1(L);
}
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBDebugger_HandleProcessEvent'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBDebugger::HandleProcessEvent(lldb::SBProcess const &,lldb::SBEvent const &,lldb::SBFile,lldb::SBFile)\n"
" lldb::SBDebugger::HandleProcessEvent(lldb::SBProcess const &,lldb::SBEvent const &,lldb::FileSP,lldb::FileSP)\n");
lua_error(L);return 0;
}
static int _wrap_SBDebugger_CreateTarget__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
bool arg5 ;
lldb::SBError *arg6 = 0 ;
lldb::SBTarget result;
SWIG_check_num_args("lldb::SBDebugger::CreateTarget",6,6)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::CreateTarget",1,"lldb::SBDebugger *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::CreateTarget",2,"char const *");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBDebugger::CreateTarget",3,"char const *");
if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBDebugger::CreateTarget",4,"char const *");
if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBDebugger::CreateTarget",5,"bool");
if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBDebugger::CreateTarget",6,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_CreateTarget",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (char *)lua_tostring(L, 3);
arg4 = (char *)lua_tostring(L, 4);
arg5 = (lua_toboolean(L, 5)!=0);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBDebugger_CreateTarget",6,SWIGTYPE_p_lldb__SBError);
}
result = (arg1)->CreateTarget((char const *)arg2,(char const *)arg3,(char const *)arg4,arg5,*arg6);
{
lldb::SBTarget * resultptr = new lldb::SBTarget((const lldb::SBTarget &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_CreateTargetWithFileAndTargetTriple(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
lldb::SBTarget result;
SWIG_check_num_args("lldb::SBDebugger::CreateTargetWithFileAndTargetTriple",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::CreateTargetWithFileAndTargetTriple",1,"lldb::SBDebugger *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::CreateTargetWithFileAndTargetTriple",2,"char const *");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBDebugger::CreateTargetWithFileAndTargetTriple",3,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_CreateTargetWithFileAndTargetTriple",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (char *)lua_tostring(L, 3);
result = (arg1)->CreateTargetWithFileAndTargetTriple((char const *)arg2,(char const *)arg3);
{
lldb::SBTarget * resultptr = new lldb::SBTarget((const lldb::SBTarget &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_CreateTargetWithFileAndArch(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
lldb::SBTarget result;
SWIG_check_num_args("lldb::SBDebugger::CreateTargetWithFileAndArch",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::CreateTargetWithFileAndArch",1,"lldb::SBDebugger *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::CreateTargetWithFileAndArch",2,"char const *");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBDebugger::CreateTargetWithFileAndArch",3,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_CreateTargetWithFileAndArch",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (char *)lua_tostring(L, 3);
result = (arg1)->CreateTargetWithFileAndArch((char const *)arg2,(char const *)arg3);
{
lldb::SBTarget * resultptr = new lldb::SBTarget((const lldb::SBTarget &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_CreateTarget__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBTarget result;
SWIG_check_num_args("lldb::SBDebugger::CreateTarget",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::CreateTarget",1,"lldb::SBDebugger *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::CreateTarget",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_CreateTarget",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->CreateTarget((char const *)arg2);
{
lldb::SBTarget * resultptr = new lldb::SBTarget((const lldb::SBTarget &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_CreateTarget(lua_State* L) {
int argc;
int argv[7]={
1,2,3,4,5,6,7
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBDebugger_CreateTarget__SWIG_1(L);
}
}
}
if (argc == 6) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[2]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[3]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[4]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBDebugger_CreateTarget__SWIG_0(L);
}
}
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBDebugger_CreateTarget'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBDebugger::CreateTarget(char const *,char const *,char const *,bool,lldb::SBError &)\n"
" lldb::SBDebugger::CreateTarget(char const *)\n");
lua_error(L);return 0;
}
static int _wrap_SBDebugger_GetDummyTarget(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBTarget result;
SWIG_check_num_args("lldb::SBDebugger::GetDummyTarget",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetDummyTarget",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetDummyTarget",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (arg1)->GetDummyTarget();
{
lldb::SBTarget * resultptr = new lldb::SBTarget((const lldb::SBTarget &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_DeleteTarget(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBTarget *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBDebugger::DeleteTarget",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::DeleteTarget",1,"lldb::SBDebugger *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::DeleteTarget",2,"lldb::SBTarget &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_DeleteTarget",1,SWIGTYPE_p_lldb__SBDebugger);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBDebugger_DeleteTarget",2,SWIGTYPE_p_lldb__SBTarget);
}
result = (bool)(arg1)->DeleteTarget(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetTargetAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
uint32_t arg2 ;
lldb::SBTarget result;
SWIG_check_num_args("lldb::SBDebugger::GetTargetAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetTargetAtIndex",1,"lldb::SBDebugger *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetTargetAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetTargetAtIndex",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetTargetAtIndex(arg2);
{
lldb::SBTarget * resultptr = new lldb::SBTarget((const lldb::SBTarget &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetIndexOfTarget(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBTarget arg2 ;
lldb::SBTarget *argp2 ;
uint32_t result;
SWIG_check_num_args("lldb::SBDebugger::GetIndexOfTarget",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetIndexOfTarget",1,"lldb::SBDebugger *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetIndexOfTarget",2,"lldb::SBTarget");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetIndexOfTarget",1,SWIGTYPE_p_lldb__SBDebugger);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBDebugger_GetIndexOfTarget",2,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = *argp2;
result = (uint32_t)(arg1)->GetIndexOfTarget(arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_FindTargetWithProcessID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::pid_t arg2 ;
lldb::SBTarget result;
SWIG_check_num_args("lldb::SBDebugger::FindTargetWithProcessID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::FindTargetWithProcessID",1,"lldb::SBDebugger *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::FindTargetWithProcessID",2,"lldb::pid_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_FindTargetWithProcessID",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (lldb::pid_t)lua_tointeger(L, 2);
result = (arg1)->FindTargetWithProcessID(arg2);
{
lldb::SBTarget * resultptr = new lldb::SBTarget((const lldb::SBTarget &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_FindTargetWithFileAndArch(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
lldb::SBTarget result;
SWIG_check_num_args("lldb::SBDebugger::FindTargetWithFileAndArch",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::FindTargetWithFileAndArch",1,"lldb::SBDebugger *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::FindTargetWithFileAndArch",2,"char const *");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBDebugger::FindTargetWithFileAndArch",3,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_FindTargetWithFileAndArch",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (char *)lua_tostring(L, 3);
result = (arg1)->FindTargetWithFileAndArch((char const *)arg2,(char const *)arg3);
{
lldb::SBTarget * resultptr = new lldb::SBTarget((const lldb::SBTarget &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetNumTargets(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBDebugger::GetNumTargets",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetNumTargets",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetNumTargets",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (uint32_t)(arg1)->GetNumTargets();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetSelectedTarget(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBTarget result;
SWIG_check_num_args("lldb::SBDebugger::GetSelectedTarget",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetSelectedTarget",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetSelectedTarget",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (arg1)->GetSelectedTarget();
{
lldb::SBTarget * resultptr = new lldb::SBTarget((const lldb::SBTarget &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetSelectedTarget(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBTarget *arg2 = 0 ;
SWIG_check_num_args("lldb::SBDebugger::SetSelectedTarget",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetSelectedTarget",1,"lldb::SBDebugger *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetSelectedTarget",2,"lldb::SBTarget &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetSelectedTarget",1,SWIGTYPE_p_lldb__SBDebugger);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBDebugger_SetSelectedTarget",2,SWIGTYPE_p_lldb__SBTarget);
}
(arg1)->SetSelectedTarget(*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetSelectedPlatform(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBPlatform result;
SWIG_check_num_args("lldb::SBDebugger::GetSelectedPlatform",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetSelectedPlatform",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetSelectedPlatform",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (arg1)->GetSelectedPlatform();
{
lldb::SBPlatform * resultptr = new lldb::SBPlatform((const lldb::SBPlatform &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBPlatform,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetSelectedPlatform(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBPlatform *arg2 = 0 ;
SWIG_check_num_args("lldb::SBDebugger::SetSelectedPlatform",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetSelectedPlatform",1,"lldb::SBDebugger *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetSelectedPlatform",2,"lldb::SBPlatform &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetSelectedPlatform",1,SWIGTYPE_p_lldb__SBDebugger);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBDebugger_SetSelectedPlatform",2,SWIGTYPE_p_lldb__SBPlatform);
}
(arg1)->SetSelectedPlatform(*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetNumPlatforms(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBDebugger::GetNumPlatforms",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetNumPlatforms",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetNumPlatforms",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (uint32_t)(arg1)->GetNumPlatforms();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetPlatformAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
uint32_t arg2 ;
lldb::SBPlatform result;
SWIG_check_num_args("lldb::SBDebugger::GetPlatformAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetPlatformAtIndex",1,"lldb::SBDebugger *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetPlatformAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetPlatformAtIndex",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetPlatformAtIndex(arg2);
{
lldb::SBPlatform * resultptr = new lldb::SBPlatform((const lldb::SBPlatform &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBPlatform,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetNumAvailablePlatforms(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBDebugger::GetNumAvailablePlatforms",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetNumAvailablePlatforms",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetNumAvailablePlatforms",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (uint32_t)(arg1)->GetNumAvailablePlatforms();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetAvailablePlatformInfoAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
uint32_t arg2 ;
lldb::SBStructuredData result;
SWIG_check_num_args("lldb::SBDebugger::GetAvailablePlatformInfoAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetAvailablePlatformInfoAtIndex",1,"lldb::SBDebugger *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetAvailablePlatformInfoAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetAvailablePlatformInfoAtIndex",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetAvailablePlatformInfoAtIndex(arg2);
{
lldb::SBStructuredData * resultptr = new lldb::SBStructuredData((const lldb::SBStructuredData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetSourceManager(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
SwigValueWrapper< lldb::SBSourceManager > result;
SWIG_check_num_args("lldb::SBDebugger::GetSourceManager",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetSourceManager",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetSourceManager",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (arg1)->GetSourceManager();
{
lldb::SBSourceManager * resultptr = new lldb::SBSourceManager((const lldb::SBSourceManager &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSourceManager,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetCurrentPlatform(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBDebugger::SetCurrentPlatform",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetCurrentPlatform",1,"lldb::SBDebugger *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetCurrentPlatform",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetCurrentPlatform",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->SetCurrentPlatform((char const *)arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetCurrentPlatformSDKRoot(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
char *arg2 = (char *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBDebugger::SetCurrentPlatformSDKRoot",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetCurrentPlatformSDKRoot",1,"lldb::SBDebugger *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetCurrentPlatformSDKRoot",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetCurrentPlatformSDKRoot",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (char *)lua_tostring(L, 2);
result = (bool)(arg1)->SetCurrentPlatformSDKRoot((char const *)arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetUseExternalEditor(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
bool arg2 ;
bool result;
SWIG_check_num_args("lldb::SBDebugger::SetUseExternalEditor",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetUseExternalEditor",1,"lldb::SBDebugger *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetUseExternalEditor",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetUseExternalEditor",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (lua_toboolean(L, 2)!=0);
result = (bool)(arg1)->SetUseExternalEditor(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetUseExternalEditor(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBDebugger::GetUseExternalEditor",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetUseExternalEditor",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetUseExternalEditor",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (bool)(arg1)->GetUseExternalEditor();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetUseColor(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
bool arg2 ;
bool result;
SWIG_check_num_args("lldb::SBDebugger::SetUseColor",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetUseColor",1,"lldb::SBDebugger *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetUseColor",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetUseColor",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (lua_toboolean(L, 2)!=0);
result = (bool)(arg1)->SetUseColor(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetUseColor(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBDebugger::GetUseColor",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetUseColor",1,"lldb::SBDebugger const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetUseColor",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (bool)((lldb::SBDebugger const *)arg1)->GetUseColor();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetDefaultArchitecture(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
size_t arg2 ;
bool result;
SWIG_check_num_args("lldb::SBDebugger::GetDefaultArchitecture",2,2)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetDefaultArchitecture",1,"char *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetDefaultArchitecture",2,"size_t");
arg1 = (char *)lua_tostring(L, 1);
arg2 = (size_t)lua_tointeger(L, 2);
result = (bool)lldb::SBDebugger::GetDefaultArchitecture(arg1,arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetDefaultArchitecture(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBDebugger::SetDefaultArchitecture",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetDefaultArchitecture",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = (bool)lldb::SBDebugger::SetDefaultArchitecture((char const *)arg1);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetScriptingLanguage(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
char *arg2 = (char *) 0 ;
lldb::ScriptLanguage result;
SWIG_check_num_args("lldb::SBDebugger::GetScriptingLanguage",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetScriptingLanguage",1,"lldb::SBDebugger *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetScriptingLanguage",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetScriptingLanguage",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (char *)lua_tostring(L, 2);
result = (lldb::ScriptLanguage)(arg1)->GetScriptingLanguage((char const *)arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetVersionString(lua_State* L) {
int SWIG_arg = 0;
char *result = 0 ;
SWIG_check_num_args("lldb::SBDebugger::GetVersionString",0,0)
result = (char *)lldb::SBDebugger::GetVersionString();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_StateAsCString(lua_State* L) {
int SWIG_arg = 0;
lldb::StateType arg1 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBDebugger::StateAsCString",1,1)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBDebugger::StateAsCString",1,"lldb::StateType");
arg1 = (lldb::StateType)lua_tointeger(L, 1);
result = (char *)lldb::SBDebugger::StateAsCString(arg1);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetBuildConfiguration(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData result;
SWIG_check_num_args("lldb::SBDebugger::GetBuildConfiguration",0,0)
result = lldb::SBDebugger::GetBuildConfiguration();
{
lldb::SBStructuredData * resultptr = new lldb::SBStructuredData((const lldb::SBStructuredData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_StateIsRunningState(lua_State* L) {
int SWIG_arg = 0;
lldb::StateType arg1 ;
bool result;
SWIG_check_num_args("lldb::SBDebugger::StateIsRunningState",1,1)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBDebugger::StateIsRunningState",1,"lldb::StateType");
arg1 = (lldb::StateType)lua_tointeger(L, 1);
result = (bool)lldb::SBDebugger::StateIsRunningState(arg1);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_StateIsStoppedState(lua_State* L) {
int SWIG_arg = 0;
lldb::StateType arg1 ;
bool result;
SWIG_check_num_args("lldb::SBDebugger::StateIsStoppedState",1,1)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBDebugger::StateIsStoppedState",1,"lldb::StateType");
arg1 = (lldb::StateType)lua_tointeger(L, 1);
result = (bool)lldb::SBDebugger::StateIsStoppedState(arg1);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_EnableLog(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
char *arg2 = (char *) 0 ;
char **arg3 = (char **) 0 ;
bool result;
SWIG_check_num_args("lldb::SBDebugger::EnableLog",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::EnableLog",1,"lldb::SBDebugger *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::EnableLog",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_EnableLog",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (char *)lua_tostring(L, 2);
{
if (lua_istable(L, 3)) {
size_t size = lua_rawlen(L, 3);
arg3 = (char **)malloc((size + 1) * sizeof(char *));
int i = 0, j = 0;
while (i++ < size) {
lua_rawgeti(L, 3, i);
if (!lua_isstring(L, -1)) {
// if current element cannot be converted to string, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain strings");
}
arg3[j++] = (char *)lua_tostring(L, -1);
lua_pop(L, 1);
}
arg3[j] = 0;
} else if (lua_isnil(L, 3)) {
// "nil" is also acceptable, equivalent as an empty table
arg3 = NULL;
} else {
return luaL_error(L, "A list of strings expected");
}
}
result = (bool)(arg1)->EnableLog((char const *)arg2,(char const **)arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
{
free((char *) arg3);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free((char *) arg3);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetLoggingCallback(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::LogOutputCallback arg2 = (lldb::LogOutputCallback) 0 ;
void *arg3 = (void *) 0 ;
SWIG_check_num_args("lldb::SBDebugger::SetLoggingCallback",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetLoggingCallback",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetLoggingCallback",1,SWIGTYPE_p_lldb__SBDebugger);
}
{
arg2 = LLDBSwigLuaCallLuaLogOutputCallback;
arg3 = (void *)L;
luaL_checktype(L, 2, LUA_TFUNCTION);
lua_settop(L, 2);
lua_pushlightuserdata(L, (void *)&LLDBSwigLuaCallLuaLogOutputCallback);
lua_insert(L, 2);
lua_settable(L, LUA_REGISTRYINDEX);
}
(arg1)->SetLoggingCallback(arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_DispatchInput(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
void *arg2 = (void *) 0 ;
size_t arg3 ;
SWIG_check_num_args("lldb::SBDebugger::DispatchInput",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::DispatchInput",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_DispatchInput",1,SWIGTYPE_p_lldb__SBDebugger);
}
{
arg2 = (void *)luaL_checklstring(L, 2, &arg3);
}
(arg1)->DispatchInput((void const *)arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_DispatchInputInterrupt(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
SWIG_check_num_args("lldb::SBDebugger::DispatchInputInterrupt",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::DispatchInputInterrupt",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_DispatchInputInterrupt",1,SWIGTYPE_p_lldb__SBDebugger);
}
(arg1)->DispatchInputInterrupt();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_DispatchInputEndOfFile(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
SWIG_check_num_args("lldb::SBDebugger::DispatchInputEndOfFile",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::DispatchInputEndOfFile",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_DispatchInputEndOfFile",1,SWIGTYPE_p_lldb__SBDebugger);
}
(arg1)->DispatchInputEndOfFile();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetInstanceName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBDebugger::GetInstanceName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetInstanceName",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetInstanceName",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (char *)(arg1)->GetInstanceName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_FindDebuggerWithID(lua_State* L) {
int SWIG_arg = 0;
int arg1 ;
lldb::SBDebugger result;
SWIG_check_num_args("lldb::SBDebugger::FindDebuggerWithID",1,1)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBDebugger::FindDebuggerWithID",1,"int");
arg1 = (int)lua_tointeger(L, 1);
result = lldb::SBDebugger::FindDebuggerWithID(arg1);
{
lldb::SBDebugger * resultptr = new lldb::SBDebugger((const lldb::SBDebugger &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBDebugger,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetInternalVariable(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBDebugger::SetInternalVariable",3,3)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetInternalVariable",1,"char const *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetInternalVariable",2,"char const *");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBDebugger::SetInternalVariable",3,"char const *");
arg1 = (char *)lua_tostring(L, 1);
arg2 = (char *)lua_tostring(L, 2);
arg3 = (char *)lua_tostring(L, 3);
result = lldb::SBDebugger::SetInternalVariable((char const *)arg1,(char const *)arg2,(char const *)arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetInternalVariableValue(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBStringList result;
SWIG_check_num_args("lldb::SBDebugger::GetInternalVariableValue",2,2)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetInternalVariableValue",1,"char const *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetInternalVariableValue",2,"char const *");
arg1 = (char *)lua_tostring(L, 1);
arg2 = (char *)lua_tostring(L, 2);
result = lldb::SBDebugger::GetInternalVariableValue((char const *)arg1,(char const *)arg2);
{
lldb::SBStringList * resultptr = new lldb::SBStringList((const lldb::SBStringList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStringList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBDebugger::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetDescription",1,"lldb::SBDebugger *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetDescription",1,SWIGTYPE_p_lldb__SBDebugger);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBDebugger_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetTerminalWidth(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBDebugger::GetTerminalWidth",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetTerminalWidth",1,"lldb::SBDebugger const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetTerminalWidth",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (uint32_t)((lldb::SBDebugger const *)arg1)->GetTerminalWidth();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetTerminalWidth(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBDebugger::SetTerminalWidth",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetTerminalWidth",1,"lldb::SBDebugger *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetTerminalWidth",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetTerminalWidth",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetTerminalWidth(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::user_id_t result;
SWIG_check_num_args("lldb::SBDebugger::GetID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetID",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetID",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (lldb::user_id_t)(arg1)->GetID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetPrompt(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBDebugger::GetPrompt",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetPrompt",1,"lldb::SBDebugger const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetPrompt",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (char *)((lldb::SBDebugger const *)arg1)->GetPrompt();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetPrompt(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBDebugger::SetPrompt",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetPrompt",1,"lldb::SBDebugger *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetPrompt",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetPrompt",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetPrompt((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetReproducerPath(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBDebugger::GetReproducerPath",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetReproducerPath",1,"lldb::SBDebugger const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetReproducerPath",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (char *)((lldb::SBDebugger const *)arg1)->GetReproducerPath();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetScriptLanguage(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::ScriptLanguage result;
SWIG_check_num_args("lldb::SBDebugger::GetScriptLanguage",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetScriptLanguage",1,"lldb::SBDebugger const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetScriptLanguage",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (lldb::ScriptLanguage)((lldb::SBDebugger const *)arg1)->GetScriptLanguage();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetScriptLanguage(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::ScriptLanguage arg2 ;
SWIG_check_num_args("lldb::SBDebugger::SetScriptLanguage",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetScriptLanguage",1,"lldb::SBDebugger *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetScriptLanguage",2,"lldb::ScriptLanguage");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetScriptLanguage",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (lldb::ScriptLanguage)lua_tointeger(L, 2);
(arg1)->SetScriptLanguage(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetCloseInputOnEOF(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBDebugger::GetCloseInputOnEOF",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetCloseInputOnEOF",1,"lldb::SBDebugger const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetCloseInputOnEOF",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (bool)((lldb::SBDebugger const *)arg1)->GetCloseInputOnEOF();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_SetCloseInputOnEOF(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBDebugger::SetCloseInputOnEOF",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetCloseInputOnEOF",1,"lldb::SBDebugger *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetCloseInputOnEOF",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_SetCloseInputOnEOF",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetCloseInputOnEOF(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetCategory__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBTypeCategory result;
SWIG_check_num_args("lldb::SBDebugger::GetCategory",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetCategory",1,"lldb::SBDebugger *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetCategory",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetCategory",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->GetCategory((char const *)arg2);
{
lldb::SBTypeCategory * resultptr = new lldb::SBTypeCategory((const lldb::SBTypeCategory &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeCategory,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetCategory__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::LanguageType arg2 ;
lldb::SBTypeCategory result;
SWIG_check_num_args("lldb::SBDebugger::GetCategory",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetCategory",1,"lldb::SBDebugger *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetCategory",2,"lldb::LanguageType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetCategory",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (lldb::LanguageType)lua_tointeger(L, 2);
result = (arg1)->GetCategory(arg2);
{
lldb::SBTypeCategory * resultptr = new lldb::SBTypeCategory((const lldb::SBTypeCategory &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeCategory,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetCategory(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBDebugger_GetCategory__SWIG_1(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBDebugger_GetCategory__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBDebugger_GetCategory'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBDebugger::GetCategory(char const *)\n"
" lldb::SBDebugger::GetCategory(lldb::LanguageType)\n");
lua_error(L);return 0;
}
static int _wrap_SBDebugger_CreateCategory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBTypeCategory result;
SWIG_check_num_args("lldb::SBDebugger::CreateCategory",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::CreateCategory",1,"lldb::SBDebugger *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::CreateCategory",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_CreateCategory",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->CreateCategory((char const *)arg2);
{
lldb::SBTypeCategory * resultptr = new lldb::SBTypeCategory((const lldb::SBTypeCategory &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeCategory,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_DeleteCategory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
char *arg2 = (char *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBDebugger::DeleteCategory",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::DeleteCategory",1,"lldb::SBDebugger *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::DeleteCategory",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_DeleteCategory",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (char *)lua_tostring(L, 2);
result = (bool)(arg1)->DeleteCategory((char const *)arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetNumCategories(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBDebugger::GetNumCategories",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetNumCategories",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetNumCategories",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (uint32_t)(arg1)->GetNumCategories();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetCategoryAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
uint32_t arg2 ;
lldb::SBTypeCategory result;
SWIG_check_num_args("lldb::SBDebugger::GetCategoryAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetCategoryAtIndex",1,"lldb::SBDebugger *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetCategoryAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetCategoryAtIndex",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetCategoryAtIndex(arg2);
{
lldb::SBTypeCategory * resultptr = new lldb::SBTypeCategory((const lldb::SBTypeCategory &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeCategory,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetDefaultCategory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBTypeCategory result;
SWIG_check_num_args("lldb::SBDebugger::GetDefaultCategory",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetDefaultCategory",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetDefaultCategory",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = (arg1)->GetDefaultCategory();
{
lldb::SBTypeCategory * resultptr = new lldb::SBTypeCategory((const lldb::SBTypeCategory &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeCategory,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetFormatForType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBTypeNameSpecifier arg2 ;
lldb::SBTypeNameSpecifier *argp2 ;
lldb::SBTypeFormat result;
SWIG_check_num_args("lldb::SBDebugger::GetFormatForType",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetFormatForType",1,"lldb::SBDebugger *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetFormatForType",2,"lldb::SBTypeNameSpecifier");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetFormatForType",1,SWIGTYPE_p_lldb__SBDebugger);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBDebugger_GetFormatForType",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
arg2 = *argp2;
result = (arg1)->GetFormatForType(arg2);
{
lldb::SBTypeFormat * resultptr = new lldb::SBTypeFormat((const lldb::SBTypeFormat &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetSummaryForType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBTypeNameSpecifier arg2 ;
lldb::SBTypeNameSpecifier *argp2 ;
lldb::SBTypeSummary result;
SWIG_check_num_args("lldb::SBDebugger::GetSummaryForType",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetSummaryForType",1,"lldb::SBDebugger *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetSummaryForType",2,"lldb::SBTypeNameSpecifier");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetSummaryForType",1,SWIGTYPE_p_lldb__SBDebugger);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBDebugger_GetSummaryForType",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
arg2 = *argp2;
result = (arg1)->GetSummaryForType(arg2);
{
lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary((const lldb::SBTypeSummary &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetFilterForType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBTypeNameSpecifier arg2 ;
lldb::SBTypeNameSpecifier *argp2 ;
lldb::SBTypeFilter result;
SWIG_check_num_args("lldb::SBDebugger::GetFilterForType",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetFilterForType",1,"lldb::SBDebugger *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetFilterForType",2,"lldb::SBTypeNameSpecifier");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetFilterForType",1,SWIGTYPE_p_lldb__SBDebugger);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBDebugger_GetFilterForType",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
arg2 = *argp2;
result = (arg1)->GetFilterForType(arg2);
{
lldb::SBTypeFilter * resultptr = new lldb::SBTypeFilter((const lldb::SBTypeFilter &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeFilter,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetSyntheticForType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::SBTypeNameSpecifier arg2 ;
lldb::SBTypeNameSpecifier *argp2 ;
lldb::SBTypeSynthetic result;
SWIG_check_num_args("lldb::SBDebugger::GetSyntheticForType",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetSyntheticForType",1,"lldb::SBDebugger *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetSyntheticForType",2,"lldb::SBTypeNameSpecifier");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetSyntheticForType",1,SWIGTYPE_p_lldb__SBDebugger);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBDebugger_GetSyntheticForType",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
arg2 = *argp2;
result = (arg1)->GetSyntheticForType(arg2);
{
lldb::SBTypeSynthetic * resultptr = new lldb::SBTypeSynthetic((const lldb::SBTypeSynthetic &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_GetScriptInterpreterInfo(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::ScriptLanguage arg2 ;
lldb::SBStructuredData result;
SWIG_check_num_args("lldb::SBDebugger::GetScriptInterpreterInfo",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetScriptInterpreterInfo",1,"lldb::SBDebugger *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetScriptInterpreterInfo",2,"lldb::ScriptLanguage");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_GetScriptInterpreterInfo",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (lldb::ScriptLanguage)lua_tointeger(L, 2);
result = (arg1)->GetScriptInterpreterInfo(arg2);
{
lldb::SBStructuredData * resultptr = new lldb::SBStructuredData((const lldb::SBStructuredData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBDebugger::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::__str__",1,"lldb::SBDebugger *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger___tostring",1,SWIGTYPE_p_lldb__SBDebugger);
}
result = lldb_SBDebugger___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_RunCommandInterpreter(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
bool arg2 ;
bool arg3 ;
lldb::SBCommandInterpreterRunOptions *arg4 = 0 ;
int *arg5 = 0 ;
bool *arg6 = 0 ;
bool *arg7 = 0 ;
int temp5 ;
bool temp6 ;
bool temp7 ;
SWIG_check_num_args("lldb::SBDebugger::RunCommandInterpreter",7,7)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::RunCommandInterpreter",1,"lldb::SBDebugger *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBDebugger::RunCommandInterpreter",2,"bool");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBDebugger::RunCommandInterpreter",3,"bool");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBDebugger::RunCommandInterpreter",4,"lldb::SBCommandInterpreterRunOptions &");
if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBDebugger::RunCommandInterpreter",5,"int &");
if(!lua_isboolean(L,6)) SWIG_fail_arg("lldb::SBDebugger::RunCommandInterpreter",6,"bool &");
if(!lua_isboolean(L,7)) SWIG_fail_arg("lldb::SBDebugger::RunCommandInterpreter",7,"bool &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_RunCommandInterpreter",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (lua_toboolean(L, 2)!=0);
arg3 = (lua_toboolean(L, 3)!=0);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){
SWIG_fail_ptr("SBDebugger_RunCommandInterpreter",4,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions);
}
temp5 = (int)lua_tointeger(L,5);
arg5 = &temp5;
temp6 = (lua_toboolean(L,6)!=0);
arg6 = &temp6;
temp7 = (lua_toboolean(L,7)!=0);
arg7 = &temp7;
(arg1)->RunCommandInterpreter(arg2,arg3,*arg4,*arg5,*arg6,*arg7);
lua_pushinteger(L, (lua_Integer) *arg5); SWIG_arg++;
lua_pushboolean(L, (int)((*arg6)!=0)); SWIG_arg++;
lua_pushboolean(L, (int)((*arg7)!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDebugger_RunREPL(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ;
lldb::LanguageType arg2 ;
char *arg3 = (char *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBDebugger::RunREPL",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::RunREPL",1,"lldb::SBDebugger *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::RunREPL",2,"lldb::LanguageType");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBDebugger::RunREPL",3,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBDebugger_RunREPL",1,SWIGTYPE_p_lldb__SBDebugger);
}
arg2 = (lldb::LanguageType)lua_tointeger(L, 2);
arg3 = (char *)lua_tostring(L, 3);
result = (arg1)->RunREPL(arg2,(char const *)arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBDebugger(void *obj) {
lldb::SBDebugger *arg1 = (lldb::SBDebugger *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBDebugger(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBDebugger);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBDebugger_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBDebugger_methods[]= {
{ "IsValid", _wrap_SBDebugger_IsValid},
{ "Clear", _wrap_SBDebugger_Clear},
{ "SetAsync", _wrap_SBDebugger_SetAsync},
{ "GetAsync", _wrap_SBDebugger_GetAsync},
{ "SkipLLDBInitFiles", _wrap_SBDebugger_SkipLLDBInitFiles},
{ "GetInputFileHandle", _wrap_SBDebugger_GetInputFileHandle},
{ "GetOutputFileHandle", _wrap_SBDebugger_GetOutputFileHandle},
{ "GetErrorFileHandle", _wrap_SBDebugger_GetErrorFileHandle},
{ "SetInputString", _wrap_SBDebugger_SetInputString},
{ "SetInputFile", _wrap_SBDebugger_SetInputFile},
{ "SetOutputFile", _wrap_SBDebugger_SetOutputFile},
{ "SetErrorFile", _wrap_SBDebugger_SetErrorFile},
{ "GetInputFile", _wrap_SBDebugger_GetInputFile},
{ "GetOutputFile", _wrap_SBDebugger_GetOutputFile},
{ "GetErrorFile", _wrap_SBDebugger_GetErrorFile},
{ "GetCommandInterpreter", _wrap_SBDebugger_GetCommandInterpreter},
{ "HandleCommand", _wrap_SBDebugger_HandleCommand},
{ "GetListener", _wrap_SBDebugger_GetListener},
{ "HandleProcessEvent", _wrap_SBDebugger_HandleProcessEvent},
{ "CreateTargetWithFileAndTargetTriple", _wrap_SBDebugger_CreateTargetWithFileAndTargetTriple},
{ "CreateTargetWithFileAndArch", _wrap_SBDebugger_CreateTargetWithFileAndArch},
{ "CreateTarget", _wrap_SBDebugger_CreateTarget},
{ "GetDummyTarget", _wrap_SBDebugger_GetDummyTarget},
{ "DeleteTarget", _wrap_SBDebugger_DeleteTarget},
{ "GetTargetAtIndex", _wrap_SBDebugger_GetTargetAtIndex},
{ "GetIndexOfTarget", _wrap_SBDebugger_GetIndexOfTarget},
{ "FindTargetWithProcessID", _wrap_SBDebugger_FindTargetWithProcessID},
{ "FindTargetWithFileAndArch", _wrap_SBDebugger_FindTargetWithFileAndArch},
{ "GetNumTargets", _wrap_SBDebugger_GetNumTargets},
{ "GetSelectedTarget", _wrap_SBDebugger_GetSelectedTarget},
{ "SetSelectedTarget", _wrap_SBDebugger_SetSelectedTarget},
{ "GetSelectedPlatform", _wrap_SBDebugger_GetSelectedPlatform},
{ "SetSelectedPlatform", _wrap_SBDebugger_SetSelectedPlatform},
{ "GetNumPlatforms", _wrap_SBDebugger_GetNumPlatforms},
{ "GetPlatformAtIndex", _wrap_SBDebugger_GetPlatformAtIndex},
{ "GetNumAvailablePlatforms", _wrap_SBDebugger_GetNumAvailablePlatforms},
{ "GetAvailablePlatformInfoAtIndex", _wrap_SBDebugger_GetAvailablePlatformInfoAtIndex},
{ "GetSourceManager", _wrap_SBDebugger_GetSourceManager},
{ "SetCurrentPlatform", _wrap_SBDebugger_SetCurrentPlatform},
{ "SetCurrentPlatformSDKRoot", _wrap_SBDebugger_SetCurrentPlatformSDKRoot},
{ "SetUseExternalEditor", _wrap_SBDebugger_SetUseExternalEditor},
{ "GetUseExternalEditor", _wrap_SBDebugger_GetUseExternalEditor},
{ "SetUseColor", _wrap_SBDebugger_SetUseColor},
{ "GetUseColor", _wrap_SBDebugger_GetUseColor},
{ "GetScriptingLanguage", _wrap_SBDebugger_GetScriptingLanguage},
{ "EnableLog", _wrap_SBDebugger_EnableLog},
{ "SetLoggingCallback", _wrap_SBDebugger_SetLoggingCallback},
{ "DispatchInput", _wrap_SBDebugger_DispatchInput},
{ "DispatchInputInterrupt", _wrap_SBDebugger_DispatchInputInterrupt},
{ "DispatchInputEndOfFile", _wrap_SBDebugger_DispatchInputEndOfFile},
{ "GetInstanceName", _wrap_SBDebugger_GetInstanceName},
{ "GetDescription", _wrap_SBDebugger_GetDescription},
{ "GetTerminalWidth", _wrap_SBDebugger_GetTerminalWidth},
{ "SetTerminalWidth", _wrap_SBDebugger_SetTerminalWidth},
{ "GetID", _wrap_SBDebugger_GetID},
{ "GetPrompt", _wrap_SBDebugger_GetPrompt},
{ "SetPrompt", _wrap_SBDebugger_SetPrompt},
{ "GetReproducerPath", _wrap_SBDebugger_GetReproducerPath},
{ "GetScriptLanguage", _wrap_SBDebugger_GetScriptLanguage},
{ "SetScriptLanguage", _wrap_SBDebugger_SetScriptLanguage},
{ "GetCloseInputOnEOF", _wrap_SBDebugger_GetCloseInputOnEOF},
{ "SetCloseInputOnEOF", _wrap_SBDebugger_SetCloseInputOnEOF},
{ "GetCategory", _wrap_SBDebugger_GetCategory},
{ "CreateCategory", _wrap_SBDebugger_CreateCategory},
{ "DeleteCategory", _wrap_SBDebugger_DeleteCategory},
{ "GetNumCategories", _wrap_SBDebugger_GetNumCategories},
{ "GetCategoryAtIndex", _wrap_SBDebugger_GetCategoryAtIndex},
{ "GetDefaultCategory", _wrap_SBDebugger_GetDefaultCategory},
{ "GetFormatForType", _wrap_SBDebugger_GetFormatForType},
{ "GetSummaryForType", _wrap_SBDebugger_GetSummaryForType},
{ "GetFilterForType", _wrap_SBDebugger_GetFilterForType},
{ "GetSyntheticForType", _wrap_SBDebugger_GetSyntheticForType},
{ "GetScriptInterpreterInfo", _wrap_SBDebugger_GetScriptInterpreterInfo},
{ "__tostring", _wrap_SBDebugger___tostring},
{ "RunCommandInterpreter", _wrap_SBDebugger_RunCommandInterpreter},
{ "RunREPL", _wrap_SBDebugger_RunREPL},
{0,0}
};
static swig_lua_method swig_SBDebugger_meta[] = {
{ "__tostring", _wrap_SBDebugger___tostring},
{0,0}
};
static swig_lua_attribute swig_SBDebugger_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBDebugger_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBDebugger_Sf_SwigStatic_methods[]= {
{ "Initialize", _wrap_SBDebugger_Initialize},
{ "InitializeWithErrorHandling", _wrap_SBDebugger_InitializeWithErrorHandling},
{ "Terminate", _wrap_SBDebugger_Terminate},
{ "Create", _wrap_SBDebugger_Create},
{ "Destroy", _wrap_SBDebugger_Destroy},
{ "MemoryPressureDetected", _wrap_SBDebugger_MemoryPressureDetected},
{ "GetDefaultArchitecture", _wrap_SBDebugger_GetDefaultArchitecture},
{ "SetDefaultArchitecture", _wrap_SBDebugger_SetDefaultArchitecture},
{ "GetVersionString", _wrap_SBDebugger_GetVersionString},
{ "StateAsCString", _wrap_SBDebugger_StateAsCString},
{ "GetBuildConfiguration", _wrap_SBDebugger_GetBuildConfiguration},
{ "StateIsRunningState", _wrap_SBDebugger_StateIsRunningState},
{ "StateIsStoppedState", _wrap_SBDebugger_StateIsStoppedState},
{ "FindDebuggerWithID", _wrap_SBDebugger_FindDebuggerWithID},
{ "SetInternalVariable", _wrap_SBDebugger_SetInternalVariable},
{ "GetInternalVariableValue", _wrap_SBDebugger_GetInternalVariableValue},
{0,0}
};
static swig_lua_class* swig_SBDebugger_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBDebugger_Sf_SwigStatic = {
"SBDebugger",
swig_SBDebugger_Sf_SwigStatic_methods,
swig_SBDebugger_Sf_SwigStatic_attributes,
swig_SBDebugger_Sf_SwigStatic_constants,
swig_SBDebugger_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBDebugger_bases[] = {0};
static const char *swig_SBDebugger_base_names[] = {0};
static swig_lua_class _wrap_class_SBDebugger = { "SBDebugger", "SBDebugger", &SWIGTYPE_p_lldb__SBDebugger,_proxy__wrap_new_SBDebugger, swig_delete_SBDebugger, swig_SBDebugger_methods, swig_SBDebugger_attributes, &swig_SBDebugger_Sf_SwigStatic, swig_SBDebugger_meta, swig_SBDebugger_bases, swig_SBDebugger_base_names };
static int _wrap_new_SBDeclaration__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDeclaration *result = 0 ;
SWIG_check_num_args("lldb::SBDeclaration::SBDeclaration",0,0)
result = (lldb::SBDeclaration *)new lldb::SBDeclaration();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBDeclaration,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBDeclaration__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDeclaration *arg1 = 0 ;
lldb::SBDeclaration *result = 0 ;
SWIG_check_num_args("lldb::SBDeclaration::SBDeclaration",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBDeclaration::SBDeclaration",1,"lldb::SBDeclaration const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){
SWIG_fail_ptr("new_SBDeclaration",1,SWIGTYPE_p_lldb__SBDeclaration);
}
result = (lldb::SBDeclaration *)new lldb::SBDeclaration((lldb::SBDeclaration const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBDeclaration,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBDeclaration(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBDeclaration__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDeclaration, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBDeclaration__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBDeclaration'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBDeclaration::SBDeclaration()\n"
" lldb::SBDeclaration::SBDeclaration(lldb::SBDeclaration const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBDeclaration_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBDeclaration::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::IsValid",1,"lldb::SBDeclaration const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){
SWIG_fail_ptr("SBDeclaration_IsValid",1,SWIGTYPE_p_lldb__SBDeclaration);
}
result = (bool)((lldb::SBDeclaration const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDeclaration_GetFileSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBDeclaration::GetFileSpec",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::GetFileSpec",1,"lldb::SBDeclaration const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){
SWIG_fail_ptr("SBDeclaration_GetFileSpec",1,SWIGTYPE_p_lldb__SBDeclaration);
}
result = ((lldb::SBDeclaration const *)arg1)->GetFileSpec();
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDeclaration_GetLine(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBDeclaration::GetLine",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::GetLine",1,"lldb::SBDeclaration const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){
SWIG_fail_ptr("SBDeclaration_GetLine",1,SWIGTYPE_p_lldb__SBDeclaration);
}
result = (uint32_t)((lldb::SBDeclaration const *)arg1)->GetLine();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDeclaration_GetColumn(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBDeclaration::GetColumn",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::GetColumn",1,"lldb::SBDeclaration const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){
SWIG_fail_ptr("SBDeclaration_GetColumn",1,SWIGTYPE_p_lldb__SBDeclaration);
}
result = (uint32_t)((lldb::SBDeclaration const *)arg1)->GetColumn();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDeclaration_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBDeclaration::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::GetDescription",1,"lldb::SBDeclaration *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDeclaration::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){
SWIG_fail_ptr("SBDeclaration_GetDescription",1,SWIGTYPE_p_lldb__SBDeclaration);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBDeclaration_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDeclaration_SetFileSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ;
lldb::SBFileSpec arg2 ;
lldb::SBFileSpec *argp2 ;
SWIG_check_num_args("lldb::SBDeclaration::SetFileSpec",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::SetFileSpec",1,"lldb::SBDeclaration *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDeclaration::SetFileSpec",2,"lldb::SBFileSpec");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){
SWIG_fail_ptr("SBDeclaration_SetFileSpec",1,SWIGTYPE_p_lldb__SBDeclaration);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBDeclaration_SetFileSpec",2,SWIGTYPE_p_lldb__SBFileSpec);
}
arg2 = *argp2;
(arg1)->SetFileSpec(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDeclaration_SetLine(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBDeclaration::SetLine",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::SetLine",1,"lldb::SBDeclaration *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDeclaration::SetLine",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){
SWIG_fail_ptr("SBDeclaration_SetLine",1,SWIGTYPE_p_lldb__SBDeclaration);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetLine(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDeclaration_SetColumn(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBDeclaration::SetColumn",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::SetColumn",1,"lldb::SBDeclaration *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDeclaration::SetColumn",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){
SWIG_fail_ptr("SBDeclaration_SetColumn",1,SWIGTYPE_p_lldb__SBDeclaration);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetColumn(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDeclaration___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ;
lldb::SBDeclaration *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBDeclaration::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::operator ==",1,"lldb::SBDeclaration const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDeclaration::operator ==",2,"lldb::SBDeclaration const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){
SWIG_fail_ptr("SBDeclaration___eq",1,SWIGTYPE_p_lldb__SBDeclaration);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBDeclaration,0))){
SWIG_fail_ptr("SBDeclaration___eq",2,SWIGTYPE_p_lldb__SBDeclaration);
}
result = (bool)((lldb::SBDeclaration const *)arg1)->operator ==((lldb::SBDeclaration const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBDeclaration___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBDeclaration::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::__str__",1,"lldb::SBDeclaration *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){
SWIG_fail_ptr("SBDeclaration___tostring",1,SWIGTYPE_p_lldb__SBDeclaration);
}
result = lldb_SBDeclaration___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBDeclaration(void *obj) {
lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBDeclaration(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBDeclaration);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBDeclaration_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBDeclaration_methods[]= {
{ "IsValid", _wrap_SBDeclaration_IsValid},
{ "GetFileSpec", _wrap_SBDeclaration_GetFileSpec},
{ "GetLine", _wrap_SBDeclaration_GetLine},
{ "GetColumn", _wrap_SBDeclaration_GetColumn},
{ "GetDescription", _wrap_SBDeclaration_GetDescription},
{ "SetFileSpec", _wrap_SBDeclaration_SetFileSpec},
{ "SetLine", _wrap_SBDeclaration_SetLine},
{ "SetColumn", _wrap_SBDeclaration_SetColumn},
{ "__eq", _wrap_SBDeclaration___eq},
{ "__tostring", _wrap_SBDeclaration___tostring},
{0,0}
};
static swig_lua_method swig_SBDeclaration_meta[] = {
{ "__eq", _wrap_SBDeclaration___eq},
{ "__tostring", _wrap_SBDeclaration___tostring},
{0,0}
};
static swig_lua_attribute swig_SBDeclaration_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBDeclaration_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBDeclaration_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBDeclaration_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBDeclaration_Sf_SwigStatic = {
"SBDeclaration",
swig_SBDeclaration_Sf_SwigStatic_methods,
swig_SBDeclaration_Sf_SwigStatic_attributes,
swig_SBDeclaration_Sf_SwigStatic_constants,
swig_SBDeclaration_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBDeclaration_bases[] = {0};
static const char *swig_SBDeclaration_base_names[] = {0};
static swig_lua_class _wrap_class_SBDeclaration = { "SBDeclaration", "SBDeclaration", &SWIGTYPE_p_lldb__SBDeclaration,_proxy__wrap_new_SBDeclaration, swig_delete_SBDeclaration, swig_SBDeclaration_methods, swig_SBDeclaration_attributes, &swig_SBDeclaration_Sf_SwigStatic, swig_SBDeclaration_meta, swig_SBDeclaration_bases, swig_SBDeclaration_base_names };
static int _wrap_new_SBError__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *result = 0 ;
SWIG_check_num_args("lldb::SBError::SBError",0,0)
result = (lldb::SBError *)new lldb::SBError();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBError__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *arg1 = 0 ;
lldb::SBError *result = 0 ;
SWIG_check_num_args("lldb::SBError::SBError",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBError::SBError",1,"lldb::SBError const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("new_SBError",1,SWIGTYPE_p_lldb__SBError);
}
result = (lldb::SBError *)new lldb::SBError((lldb::SBError const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBError(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBError__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBError__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBError'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBError::SBError()\n"
" lldb::SBError::SBError(lldb::SBError const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBError_GetCString(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *arg1 = (lldb::SBError *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBError::GetCString",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::GetCString",1,"lldb::SBError const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBError_GetCString",1,SWIGTYPE_p_lldb__SBError);
}
result = (char *)((lldb::SBError const *)arg1)->GetCString();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBError_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *arg1 = (lldb::SBError *) 0 ;
SWIG_check_num_args("lldb::SBError::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::Clear",1,"lldb::SBError *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBError_Clear",1,SWIGTYPE_p_lldb__SBError);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBError_Fail(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *arg1 = (lldb::SBError *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBError::Fail",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::Fail",1,"lldb::SBError const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBError_Fail",1,SWIGTYPE_p_lldb__SBError);
}
result = (bool)((lldb::SBError const *)arg1)->Fail();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBError_Success(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *arg1 = (lldb::SBError *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBError::Success",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::Success",1,"lldb::SBError const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBError_Success",1,SWIGTYPE_p_lldb__SBError);
}
result = (bool)((lldb::SBError const *)arg1)->Success();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBError_GetError(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *arg1 = (lldb::SBError *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBError::GetError",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::GetError",1,"lldb::SBError const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBError_GetError",1,SWIGTYPE_p_lldb__SBError);
}
result = (uint32_t)((lldb::SBError const *)arg1)->GetError();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBError_GetType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *arg1 = (lldb::SBError *) 0 ;
lldb::ErrorType result;
SWIG_check_num_args("lldb::SBError::GetType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::GetType",1,"lldb::SBError const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBError_GetType",1,SWIGTYPE_p_lldb__SBError);
}
result = (lldb::ErrorType)((lldb::SBError const *)arg1)->GetType();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBError_SetError(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *arg1 = (lldb::SBError *) 0 ;
uint32_t arg2 ;
lldb::ErrorType arg3 ;
SWIG_check_num_args("lldb::SBError::SetError",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::SetError",1,"lldb::SBError *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBError::SetError",2,"uint32_t");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBError::SetError",3,"lldb::ErrorType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBError_SetError",1,SWIGTYPE_p_lldb__SBError);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
arg3 = (lldb::ErrorType)lua_tointeger(L, 3);
(arg1)->SetError(arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBError_SetErrorToErrno(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *arg1 = (lldb::SBError *) 0 ;
SWIG_check_num_args("lldb::SBError::SetErrorToErrno",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::SetErrorToErrno",1,"lldb::SBError *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBError_SetErrorToErrno",1,SWIGTYPE_p_lldb__SBError);
}
(arg1)->SetErrorToErrno();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBError_SetErrorToGenericError(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *arg1 = (lldb::SBError *) 0 ;
SWIG_check_num_args("lldb::SBError::SetErrorToGenericError",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::SetErrorToGenericError",1,"lldb::SBError *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBError_SetErrorToGenericError",1,SWIGTYPE_p_lldb__SBError);
}
(arg1)->SetErrorToGenericError();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBError_SetErrorString(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *arg1 = (lldb::SBError *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBError::SetErrorString",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::SetErrorString",1,"lldb::SBError *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBError::SetErrorString",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBError_SetErrorString",1,SWIGTYPE_p_lldb__SBError);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetErrorString((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBError_SetErrorStringWithFormat__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *arg1 = (lldb::SBError *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
char *arg5 = (char *) 0 ;
int result;
SWIG_check_num_args("lldb::SBError::SetErrorStringWithFormat",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",1,"lldb::SBError *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",2,"char const *");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",3,"char *");
if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",4,"char *");
if(!SWIG_lua_isnilstring(L,5)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",5,"char *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBError_SetErrorStringWithFormat",1,SWIGTYPE_p_lldb__SBError);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (char *)lua_tostring(L, 3);
arg4 = (char *)lua_tostring(L, 4);
arg5 = (char *)lua_tostring(L, 5);
result = (int)(arg1)->SetErrorStringWithFormat((char const *)arg2,arg3,arg4,arg5);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBError_SetErrorStringWithFormat__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *arg1 = (lldb::SBError *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
int result;
SWIG_check_num_args("lldb::SBError::SetErrorStringWithFormat",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",1,"lldb::SBError *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",2,"char const *");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",3,"char *");
if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",4,"char *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBError_SetErrorStringWithFormat",1,SWIGTYPE_p_lldb__SBError);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (char *)lua_tostring(L, 3);
arg4 = (char *)lua_tostring(L, 4);
result = (int)(arg1)->SetErrorStringWithFormat((char const *)arg2,arg3,arg4);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBError_SetErrorStringWithFormat__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *arg1 = (lldb::SBError *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
int result;
SWIG_check_num_args("lldb::SBError::SetErrorStringWithFormat",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",1,"lldb::SBError *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",2,"char const *");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",3,"char *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBError_SetErrorStringWithFormat",1,SWIGTYPE_p_lldb__SBError);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (char *)lua_tostring(L, 3);
result = (int)(arg1)->SetErrorStringWithFormat((char const *)arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBError_SetErrorStringWithFormat__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *arg1 = (lldb::SBError *) 0 ;
char *arg2 = (char *) 0 ;
int result;
SWIG_check_num_args("lldb::SBError::SetErrorStringWithFormat",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",1,"lldb::SBError *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBError_SetErrorStringWithFormat",1,SWIGTYPE_p_lldb__SBError);
}
arg2 = (char *)lua_tostring(L, 2);
result = (int)(arg1)->SetErrorStringWithFormat((char const *)arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBError_SetErrorStringWithFormat(lua_State* L) {
int argc;
int argv[6]={
1,2,3,4,5,6
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBError, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBError_SetErrorStringWithFormat__SWIG_3(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBError, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[2]);
}
if (_v) {
return _wrap_SBError_SetErrorStringWithFormat__SWIG_2(L);
}
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBError, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[2]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[3]);
}
if (_v) {
return _wrap_SBError_SetErrorStringWithFormat__SWIG_1(L);
}
}
}
}
}
if (argc == 5) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBError, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[2]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[3]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[4]);
}
if (_v) {
return _wrap_SBError_SetErrorStringWithFormat__SWIG_0(L);
}
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBError_SetErrorStringWithFormat'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBError::SetErrorStringWithFormat(char const *,char *,char *,char *)\n"
" lldb::SBError::SetErrorStringWithFormat(char const *,char *,char *)\n"
" lldb::SBError::SetErrorStringWithFormat(char const *,char *)\n"
" lldb::SBError::SetErrorStringWithFormat(char const *)\n");
lua_error(L);return 0;
}
static int _wrap_SBError_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *arg1 = (lldb::SBError *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBError::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::IsValid",1,"lldb::SBError const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBError_IsValid",1,SWIGTYPE_p_lldb__SBError);
}
result = (bool)((lldb::SBError const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBError_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *arg1 = (lldb::SBError *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBError::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::GetDescription",1,"lldb::SBError *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBError::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBError_GetDescription",1,SWIGTYPE_p_lldb__SBError);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBError_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBError___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBError *arg1 = (lldb::SBError *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBError::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::__str__",1,"lldb::SBError *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBError___tostring",1,SWIGTYPE_p_lldb__SBError);
}
result = lldb_SBError___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBError(void *obj) {
lldb::SBError *arg1 = (lldb::SBError *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBError(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBError);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBError_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBError_methods[]= {
{ "GetCString", _wrap_SBError_GetCString},
{ "Clear", _wrap_SBError_Clear},
{ "Fail", _wrap_SBError_Fail},
{ "Success", _wrap_SBError_Success},
{ "GetError", _wrap_SBError_GetError},
{ "GetType", _wrap_SBError_GetType},
{ "SetError", _wrap_SBError_SetError},
{ "SetErrorToErrno", _wrap_SBError_SetErrorToErrno},
{ "SetErrorToGenericError", _wrap_SBError_SetErrorToGenericError},
{ "SetErrorString", _wrap_SBError_SetErrorString},
{ "SetErrorStringWithFormat", _wrap_SBError_SetErrorStringWithFormat},
{ "IsValid", _wrap_SBError_IsValid},
{ "GetDescription", _wrap_SBError_GetDescription},
{ "__tostring", _wrap_SBError___tostring},
{0,0}
};
static swig_lua_method swig_SBError_meta[] = {
{ "__tostring", _wrap_SBError___tostring},
{0,0}
};
static swig_lua_attribute swig_SBError_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBError_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBError_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBError_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBError_Sf_SwigStatic = {
"SBError",
swig_SBError_Sf_SwigStatic_methods,
swig_SBError_Sf_SwigStatic_attributes,
swig_SBError_Sf_SwigStatic_constants,
swig_SBError_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBError_bases[] = {0};
static const char *swig_SBError_base_names[] = {0};
static swig_lua_class _wrap_class_SBError = { "SBError", "SBError", &SWIGTYPE_p_lldb__SBError,_proxy__wrap_new_SBError, swig_delete_SBError, swig_SBError_methods, swig_SBError_attributes, &swig_SBError_Sf_SwigStatic, swig_SBError_meta, swig_SBError_bases, swig_SBError_base_names };
static int _wrap_new_SBEnvironment__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEnvironment *result = 0 ;
SWIG_check_num_args("lldb::SBEnvironment::SBEnvironment",0,0)
result = (lldb::SBEnvironment *)new lldb::SBEnvironment();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBEnvironment,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBEnvironment__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEnvironment *arg1 = 0 ;
lldb::SBEnvironment *result = 0 ;
SWIG_check_num_args("lldb::SBEnvironment::SBEnvironment",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBEnvironment::SBEnvironment",1,"lldb::SBEnvironment const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){
SWIG_fail_ptr("new_SBEnvironment",1,SWIGTYPE_p_lldb__SBEnvironment);
}
result = (lldb::SBEnvironment *)new lldb::SBEnvironment((lldb::SBEnvironment const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBEnvironment,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBEnvironment(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBEnvironment__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBEnvironment, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBEnvironment__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBEnvironment'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBEnvironment::SBEnvironment()\n"
" lldb::SBEnvironment::SBEnvironment(lldb::SBEnvironment const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBEnvironment_GetNumValues(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBEnvironment::GetNumValues",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::GetNumValues",1,"lldb::SBEnvironment *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){
SWIG_fail_ptr("SBEnvironment_GetNumValues",1,SWIGTYPE_p_lldb__SBEnvironment);
}
result = (arg1)->GetNumValues();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBEnvironment_Get(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ;
char *arg2 = (char *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBEnvironment::Get",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::Get",1,"lldb::SBEnvironment *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBEnvironment::Get",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){
SWIG_fail_ptr("SBEnvironment_Get",1,SWIGTYPE_p_lldb__SBEnvironment);
}
arg2 = (char *)lua_tostring(L, 2);
result = (char *)(arg1)->Get((char const *)arg2);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBEnvironment_GetNameAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ;
size_t arg2 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBEnvironment::GetNameAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::GetNameAtIndex",1,"lldb::SBEnvironment *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBEnvironment::GetNameAtIndex",2,"size_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){
SWIG_fail_ptr("SBEnvironment_GetNameAtIndex",1,SWIGTYPE_p_lldb__SBEnvironment);
}
arg2 = (size_t)lua_tointeger(L, 2);
result = (char *)(arg1)->GetNameAtIndex(arg2);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBEnvironment_GetValueAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ;
size_t arg2 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBEnvironment::GetValueAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::GetValueAtIndex",1,"lldb::SBEnvironment *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBEnvironment::GetValueAtIndex",2,"size_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){
SWIG_fail_ptr("SBEnvironment_GetValueAtIndex",1,SWIGTYPE_p_lldb__SBEnvironment);
}
arg2 = (size_t)lua_tointeger(L, 2);
result = (char *)(arg1)->GetValueAtIndex(arg2);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBEnvironment_GetEntries(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ;
lldb::SBStringList result;
SWIG_check_num_args("lldb::SBEnvironment::GetEntries",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::GetEntries",1,"lldb::SBEnvironment *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){
SWIG_fail_ptr("SBEnvironment_GetEntries",1,SWIGTYPE_p_lldb__SBEnvironment);
}
result = (arg1)->GetEntries();
{
lldb::SBStringList * resultptr = new lldb::SBStringList((const lldb::SBStringList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStringList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBEnvironment_PutEntry(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBEnvironment::PutEntry",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::PutEntry",1,"lldb::SBEnvironment *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBEnvironment::PutEntry",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){
SWIG_fail_ptr("SBEnvironment_PutEntry",1,SWIGTYPE_p_lldb__SBEnvironment);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->PutEntry((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBEnvironment_SetEntries(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ;
lldb::SBStringList *arg2 = 0 ;
bool arg3 ;
SWIG_check_num_args("lldb::SBEnvironment::SetEntries",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::SetEntries",1,"lldb::SBEnvironment *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBEnvironment::SetEntries",2,"lldb::SBStringList const &");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBEnvironment::SetEntries",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){
SWIG_fail_ptr("SBEnvironment_SetEntries",1,SWIGTYPE_p_lldb__SBEnvironment);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBEnvironment_SetEntries",2,SWIGTYPE_p_lldb__SBStringList);
}
arg3 = (lua_toboolean(L, 3)!=0);
(arg1)->SetEntries((lldb::SBStringList const &)*arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBEnvironment_Set(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
bool arg4 ;
bool result;
SWIG_check_num_args("lldb::SBEnvironment::Set",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::Set",1,"lldb::SBEnvironment *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBEnvironment::Set",2,"char const *");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBEnvironment::Set",3,"char const *");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBEnvironment::Set",4,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){
SWIG_fail_ptr("SBEnvironment_Set",1,SWIGTYPE_p_lldb__SBEnvironment);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (char *)lua_tostring(L, 3);
arg4 = (lua_toboolean(L, 4)!=0);
result = (bool)(arg1)->Set((char const *)arg2,(char const *)arg3,arg4);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBEnvironment_Unset(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ;
char *arg2 = (char *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBEnvironment::Unset",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::Unset",1,"lldb::SBEnvironment *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBEnvironment::Unset",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){
SWIG_fail_ptr("SBEnvironment_Unset",1,SWIGTYPE_p_lldb__SBEnvironment);
}
arg2 = (char *)lua_tostring(L, 2);
result = (bool)(arg1)->Unset((char const *)arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBEnvironment_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ;
SWIG_check_num_args("lldb::SBEnvironment::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::Clear",1,"lldb::SBEnvironment *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){
SWIG_fail_ptr("SBEnvironment_Clear",1,SWIGTYPE_p_lldb__SBEnvironment);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBEnvironment(void *obj) {
lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBEnvironment(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBEnvironment);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBEnvironment_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBEnvironment_methods[]= {
{ "GetNumValues", _wrap_SBEnvironment_GetNumValues},
{ "Get", _wrap_SBEnvironment_Get},
{ "GetNameAtIndex", _wrap_SBEnvironment_GetNameAtIndex},
{ "GetValueAtIndex", _wrap_SBEnvironment_GetValueAtIndex},
{ "GetEntries", _wrap_SBEnvironment_GetEntries},
{ "PutEntry", _wrap_SBEnvironment_PutEntry},
{ "SetEntries", _wrap_SBEnvironment_SetEntries},
{ "Set", _wrap_SBEnvironment_Set},
{ "Unset", _wrap_SBEnvironment_Unset},
{ "Clear", _wrap_SBEnvironment_Clear},
{0,0}
};
static swig_lua_method swig_SBEnvironment_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBEnvironment_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBEnvironment_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBEnvironment_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBEnvironment_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBEnvironment_Sf_SwigStatic = {
"SBEnvironment",
swig_SBEnvironment_Sf_SwigStatic_methods,
swig_SBEnvironment_Sf_SwigStatic_attributes,
swig_SBEnvironment_Sf_SwigStatic_constants,
swig_SBEnvironment_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBEnvironment_bases[] = {0};
static const char *swig_SBEnvironment_base_names[] = {0};
static swig_lua_class _wrap_class_SBEnvironment = { "SBEnvironment", "SBEnvironment", &SWIGTYPE_p_lldb__SBEnvironment,_proxy__wrap_new_SBEnvironment, swig_delete_SBEnvironment, swig_SBEnvironment_methods, swig_SBEnvironment_attributes, &swig_SBEnvironment_Sf_SwigStatic, swig_SBEnvironment_meta, swig_SBEnvironment_bases, swig_SBEnvironment_base_names };
static int _wrap_new_SBEvent__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *result = 0 ;
SWIG_check_num_args("lldb::SBEvent::SBEvent",0,0)
result = (lldb::SBEvent *)new lldb::SBEvent();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBEvent,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBEvent__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
lldb::SBEvent *result = 0 ;
SWIG_check_num_args("lldb::SBEvent::SBEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBEvent::SBEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("new_SBEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (lldb::SBEvent *)new lldb::SBEvent((lldb::SBEvent const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBEvent,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBEvent__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
uint32_t arg1 ;
char *arg2 = (char *) 0 ;
uint32_t arg3 ;
lldb::SBEvent *result = 0 ;
SWIG_check_num_args("lldb::SBEvent::SBEvent",2,2)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBEvent::SBEvent",1,"uint32_t");
arg1 = (uint32_t)lua_tointeger(L, 1);
{
arg2 = (char *)luaL_checklstring(L, 2, (size_t *)&arg3);
}
result = (lldb::SBEvent *)new lldb::SBEvent(arg1,(char const *)arg2,arg3);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBEvent,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBEvent(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBEvent__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBEvent__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
_v = lua_isnumber(L,argv[0]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
if (argc <= 2) {
return _wrap_new_SBEvent__SWIG_2(L);
}
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_new_SBEvent__SWIG_2(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBEvent'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBEvent::SBEvent()\n"
" lldb::SBEvent::SBEvent(lldb::SBEvent const &)\n"
" lldb::SBEvent::SBEvent(uint32_t,char const *,uint32_t)\n");
lua_error(L);return 0;
}
static int _wrap_SBEvent_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBEvent::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEvent::IsValid",1,"lldb::SBEvent const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBEvent_IsValid",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)((lldb::SBEvent const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBEvent_GetDataFlavor(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBEvent::GetDataFlavor",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEvent::GetDataFlavor",1,"lldb::SBEvent *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBEvent_GetDataFlavor",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (char *)(arg1)->GetDataFlavor();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBEvent_GetType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBEvent::GetType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEvent::GetType",1,"lldb::SBEvent const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBEvent_GetType",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (uint32_t)((lldb::SBEvent const *)arg1)->GetType();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBEvent_GetBroadcaster(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ;
lldb::SBBroadcaster result;
SWIG_check_num_args("lldb::SBEvent::GetBroadcaster",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEvent::GetBroadcaster",1,"lldb::SBEvent const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBEvent_GetBroadcaster",1,SWIGTYPE_p_lldb__SBEvent);
}
result = ((lldb::SBEvent const *)arg1)->GetBroadcaster();
{
lldb::SBBroadcaster * resultptr = new lldb::SBBroadcaster((const lldb::SBBroadcaster &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBroadcaster,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBEvent_GetBroadcasterClass(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBEvent::GetBroadcasterClass",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEvent::GetBroadcasterClass",1,"lldb::SBEvent const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBEvent_GetBroadcasterClass",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (char *)((lldb::SBEvent const *)arg1)->GetBroadcasterClass();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBEvent_BroadcasterMatchesRef(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ;
lldb::SBBroadcaster *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBEvent::BroadcasterMatchesRef",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEvent::BroadcasterMatchesRef",1,"lldb::SBEvent *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBEvent::BroadcasterMatchesRef",2,"lldb::SBBroadcaster const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBEvent_BroadcasterMatchesRef",1,SWIGTYPE_p_lldb__SBEvent);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBEvent_BroadcasterMatchesRef",2,SWIGTYPE_p_lldb__SBBroadcaster);
}
result = (bool)(arg1)->BroadcasterMatchesRef((lldb::SBBroadcaster const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBEvent_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ;
SWIG_check_num_args("lldb::SBEvent::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEvent::Clear",1,"lldb::SBEvent *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBEvent_Clear",1,SWIGTYPE_p_lldb__SBEvent);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBEvent_GetCStringFromEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBEvent::GetCStringFromEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBEvent::GetCStringFromEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBEvent_GetCStringFromEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (char *)lldb::SBEvent::GetCStringFromEvent((lldb::SBEvent const &)*arg1);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBEvent_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBEvent::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEvent::GetDescription",1,"lldb::SBEvent const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBEvent::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBEvent_GetDescription",1,SWIGTYPE_p_lldb__SBEvent);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBEvent_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)((lldb::SBEvent const *)arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBEvent(void *obj) {
lldb::SBEvent *arg1 = (lldb::SBEvent *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBEvent(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBEvent);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBEvent_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBEvent_methods[]= {
{ "IsValid", _wrap_SBEvent_IsValid},
{ "GetDataFlavor", _wrap_SBEvent_GetDataFlavor},
{ "GetType", _wrap_SBEvent_GetType},
{ "GetBroadcaster", _wrap_SBEvent_GetBroadcaster},
{ "GetBroadcasterClass", _wrap_SBEvent_GetBroadcasterClass},
{ "BroadcasterMatchesRef", _wrap_SBEvent_BroadcasterMatchesRef},
{ "Clear", _wrap_SBEvent_Clear},
{ "GetDescription", _wrap_SBEvent_GetDescription},
{0,0}
};
static swig_lua_method swig_SBEvent_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBEvent_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBEvent_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBEvent_Sf_SwigStatic_methods[]= {
{ "GetCStringFromEvent", _wrap_SBEvent_GetCStringFromEvent},
{0,0}
};
static swig_lua_class* swig_SBEvent_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBEvent_Sf_SwigStatic = {
"SBEvent",
swig_SBEvent_Sf_SwigStatic_methods,
swig_SBEvent_Sf_SwigStatic_attributes,
swig_SBEvent_Sf_SwigStatic_constants,
swig_SBEvent_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBEvent_bases[] = {0};
static const char *swig_SBEvent_base_names[] = {0};
static swig_lua_class _wrap_class_SBEvent = { "SBEvent", "SBEvent", &SWIGTYPE_p_lldb__SBEvent,_proxy__wrap_new_SBEvent, swig_delete_SBEvent, swig_SBEvent_methods, swig_SBEvent_attributes, &swig_SBEvent_Sf_SwigStatic, swig_SBEvent_meta, swig_SBEvent_bases, swig_SBEvent_base_names };
static int _wrap_new_SBExecutionContext__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExecutionContext *result = 0 ;
SWIG_check_num_args("lldb::SBExecutionContext::SBExecutionContext",0,0)
result = (lldb::SBExecutionContext *)new lldb::SBExecutionContext();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBExecutionContext,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBExecutionContext__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExecutionContext *arg1 = 0 ;
lldb::SBExecutionContext *result = 0 ;
SWIG_check_num_args("lldb::SBExecutionContext::SBExecutionContext",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBExecutionContext::SBExecutionContext",1,"lldb::SBExecutionContext const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExecutionContext,0))){
SWIG_fail_ptr("new_SBExecutionContext",1,SWIGTYPE_p_lldb__SBExecutionContext);
}
result = (lldb::SBExecutionContext *)new lldb::SBExecutionContext((lldb::SBExecutionContext const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBExecutionContext,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBExecutionContext__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = 0 ;
lldb::SBExecutionContext *result = 0 ;
SWIG_check_num_args("lldb::SBExecutionContext::SBExecutionContext",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBExecutionContext::SBExecutionContext",1,"lldb::SBTarget const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("new_SBExecutionContext",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (lldb::SBExecutionContext *)new lldb::SBExecutionContext((lldb::SBTarget const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBExecutionContext,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBExecutionContext__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = 0 ;
lldb::SBExecutionContext *result = 0 ;
SWIG_check_num_args("lldb::SBExecutionContext::SBExecutionContext",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBExecutionContext::SBExecutionContext",1,"lldb::SBProcess const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("new_SBExecutionContext",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (lldb::SBExecutionContext *)new lldb::SBExecutionContext((lldb::SBProcess const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBExecutionContext,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBExecutionContext__SWIG_4(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread arg1 ;
lldb::SBThread *argp1 ;
lldb::SBExecutionContext *result = 0 ;
SWIG_check_num_args("lldb::SBExecutionContext::SBExecutionContext",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBExecutionContext::SBExecutionContext",1,"lldb::SBThread");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("new_SBExecutionContext",1,SWIGTYPE_p_lldb__SBThread);
}
arg1 = *argp1;
result = (lldb::SBExecutionContext *)new lldb::SBExecutionContext(arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBExecutionContext,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBExecutionContext__SWIG_5(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = 0 ;
lldb::SBExecutionContext *result = 0 ;
SWIG_check_num_args("lldb::SBExecutionContext::SBExecutionContext",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBExecutionContext::SBExecutionContext",1,"lldb::SBFrame const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("new_SBExecutionContext",1,SWIGTYPE_p_lldb__SBFrame);
}
result = (lldb::SBExecutionContext *)new lldb::SBExecutionContext((lldb::SBFrame const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBExecutionContext,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBExecutionContext(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBExecutionContext__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExecutionContext, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBExecutionContext__SWIG_1(L);
}
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBExecutionContext__SWIG_2(L);
}
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBExecutionContext__SWIG_3(L);
}
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBExecutionContext__SWIG_4(L);
}
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBExecutionContext__SWIG_5(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBExecutionContext'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBExecutionContext::SBExecutionContext()\n"
" lldb::SBExecutionContext::SBExecutionContext(lldb::SBExecutionContext const &)\n"
" lldb::SBExecutionContext::SBExecutionContext(lldb::SBTarget const &)\n"
" lldb::SBExecutionContext::SBExecutionContext(lldb::SBProcess const &)\n"
" lldb::SBExecutionContext::SBExecutionContext(lldb::SBThread)\n"
" lldb::SBExecutionContext::SBExecutionContext(lldb::SBFrame const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBExecutionContext_GetTarget(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExecutionContext *arg1 = (lldb::SBExecutionContext *) 0 ;
lldb::SBTarget result;
SWIG_check_num_args("lldb::SBExecutionContext::GetTarget",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExecutionContext::GetTarget",1,"lldb::SBExecutionContext const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExecutionContext,0))){
SWIG_fail_ptr("SBExecutionContext_GetTarget",1,SWIGTYPE_p_lldb__SBExecutionContext);
}
result = ((lldb::SBExecutionContext const *)arg1)->GetTarget();
{
lldb::SBTarget * resultptr = new lldb::SBTarget((const lldb::SBTarget &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExecutionContext_GetProcess(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExecutionContext *arg1 = (lldb::SBExecutionContext *) 0 ;
lldb::SBProcess result;
SWIG_check_num_args("lldb::SBExecutionContext::GetProcess",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExecutionContext::GetProcess",1,"lldb::SBExecutionContext const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExecutionContext,0))){
SWIG_fail_ptr("SBExecutionContext_GetProcess",1,SWIGTYPE_p_lldb__SBExecutionContext);
}
result = ((lldb::SBExecutionContext const *)arg1)->GetProcess();
{
lldb::SBProcess * resultptr = new lldb::SBProcess((const lldb::SBProcess &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExecutionContext_GetThread(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExecutionContext *arg1 = (lldb::SBExecutionContext *) 0 ;
lldb::SBThread result;
SWIG_check_num_args("lldb::SBExecutionContext::GetThread",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExecutionContext::GetThread",1,"lldb::SBExecutionContext const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExecutionContext,0))){
SWIG_fail_ptr("SBExecutionContext_GetThread",1,SWIGTYPE_p_lldb__SBExecutionContext);
}
result = ((lldb::SBExecutionContext const *)arg1)->GetThread();
{
lldb::SBThread * resultptr = new lldb::SBThread((const lldb::SBThread &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExecutionContext_GetFrame(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExecutionContext *arg1 = (lldb::SBExecutionContext *) 0 ;
lldb::SBFrame result;
SWIG_check_num_args("lldb::SBExecutionContext::GetFrame",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExecutionContext::GetFrame",1,"lldb::SBExecutionContext const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExecutionContext,0))){
SWIG_fail_ptr("SBExecutionContext_GetFrame",1,SWIGTYPE_p_lldb__SBExecutionContext);
}
result = ((lldb::SBExecutionContext const *)arg1)->GetFrame();
{
lldb::SBFrame * resultptr = new lldb::SBFrame((const lldb::SBFrame &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFrame,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBExecutionContext(void *obj) {
lldb::SBExecutionContext *arg1 = (lldb::SBExecutionContext *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBExecutionContext(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBExecutionContext);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBExecutionContext_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBExecutionContext_methods[]= {
{ "GetTarget", _wrap_SBExecutionContext_GetTarget},
{ "GetProcess", _wrap_SBExecutionContext_GetProcess},
{ "GetThread", _wrap_SBExecutionContext_GetThread},
{ "GetFrame", _wrap_SBExecutionContext_GetFrame},
{0,0}
};
static swig_lua_method swig_SBExecutionContext_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBExecutionContext_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBExecutionContext_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBExecutionContext_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBExecutionContext_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBExecutionContext_Sf_SwigStatic = {
"SBExecutionContext",
swig_SBExecutionContext_Sf_SwigStatic_methods,
swig_SBExecutionContext_Sf_SwigStatic_attributes,
swig_SBExecutionContext_Sf_SwigStatic_constants,
swig_SBExecutionContext_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBExecutionContext_bases[] = {0};
static const char *swig_SBExecutionContext_base_names[] = {0};
static swig_lua_class _wrap_class_SBExecutionContext = { "SBExecutionContext", "SBExecutionContext", &SWIGTYPE_p_lldb__SBExecutionContext,_proxy__wrap_new_SBExecutionContext, swig_delete_SBExecutionContext, swig_SBExecutionContext_methods, swig_SBExecutionContext_attributes, &swig_SBExecutionContext_Sf_SwigStatic, swig_SBExecutionContext_meta, swig_SBExecutionContext_bases, swig_SBExecutionContext_base_names };
static int _wrap_new_SBExpressionOptions__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *result = 0 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SBExpressionOptions",0,0)
result = (lldb::SBExpressionOptions *)new lldb::SBExpressionOptions();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBExpressionOptions,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBExpressionOptions__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = 0 ;
lldb::SBExpressionOptions *result = 0 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SBExpressionOptions",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SBExpressionOptions",1,"lldb::SBExpressionOptions const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("new_SBExpressionOptions",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (lldb::SBExpressionOptions *)new lldb::SBExpressionOptions((lldb::SBExpressionOptions const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBExpressionOptions,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBExpressionOptions(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBExpressionOptions__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBExpressionOptions__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBExpressionOptions'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBExpressionOptions::SBExpressionOptions()\n"
" lldb::SBExpressionOptions::SBExpressionOptions(lldb::SBExpressionOptions const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBExpressionOptions_GetCoerceResultToId(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBExpressionOptions::GetCoerceResultToId",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetCoerceResultToId",1,"lldb::SBExpressionOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_GetCoerceResultToId",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (bool)((lldb::SBExpressionOptions const *)arg1)->GetCoerceResultToId();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetCoerceResultToId__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetCoerceResultToId",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetCoerceResultToId",1,"lldb::SBExpressionOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetCoerceResultToId",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetCoerceResultToId",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetCoerceResultToId(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetCoerceResultToId__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetCoerceResultToId",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetCoerceResultToId",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetCoerceResultToId",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
(arg1)->SetCoerceResultToId();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetCoerceResultToId(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBExpressionOptions_SetCoerceResultToId__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_SBExpressionOptions_SetCoerceResultToId__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetCoerceResultToId'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBExpressionOptions::SetCoerceResultToId(bool)\n"
" lldb::SBExpressionOptions::SetCoerceResultToId()\n");
lua_error(L);return 0;
}
static int _wrap_SBExpressionOptions_GetUnwindOnError(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBExpressionOptions::GetUnwindOnError",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetUnwindOnError",1,"lldb::SBExpressionOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_GetUnwindOnError",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (bool)((lldb::SBExpressionOptions const *)arg1)->GetUnwindOnError();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetUnwindOnError__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetUnwindOnError",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetUnwindOnError",1,"lldb::SBExpressionOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetUnwindOnError",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetUnwindOnError",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetUnwindOnError(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetUnwindOnError__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetUnwindOnError",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetUnwindOnError",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetUnwindOnError",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
(arg1)->SetUnwindOnError();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetUnwindOnError(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBExpressionOptions_SetUnwindOnError__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_SBExpressionOptions_SetUnwindOnError__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetUnwindOnError'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBExpressionOptions::SetUnwindOnError(bool)\n"
" lldb::SBExpressionOptions::SetUnwindOnError()\n");
lua_error(L);return 0;
}
static int _wrap_SBExpressionOptions_GetIgnoreBreakpoints(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBExpressionOptions::GetIgnoreBreakpoints",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetIgnoreBreakpoints",1,"lldb::SBExpressionOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_GetIgnoreBreakpoints",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (bool)((lldb::SBExpressionOptions const *)arg1)->GetIgnoreBreakpoints();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetIgnoreBreakpoints__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetIgnoreBreakpoints",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetIgnoreBreakpoints",1,"lldb::SBExpressionOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetIgnoreBreakpoints",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetIgnoreBreakpoints",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetIgnoreBreakpoints(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetIgnoreBreakpoints__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetIgnoreBreakpoints",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetIgnoreBreakpoints",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetIgnoreBreakpoints",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
(arg1)->SetIgnoreBreakpoints();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetIgnoreBreakpoints(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBExpressionOptions_SetIgnoreBreakpoints__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_SBExpressionOptions_SetIgnoreBreakpoints__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetIgnoreBreakpoints'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBExpressionOptions::SetIgnoreBreakpoints(bool)\n"
" lldb::SBExpressionOptions::SetIgnoreBreakpoints()\n");
lua_error(L);return 0;
}
static int _wrap_SBExpressionOptions_GetFetchDynamicValue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
lldb::DynamicValueType result;
SWIG_check_num_args("lldb::SBExpressionOptions::GetFetchDynamicValue",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetFetchDynamicValue",1,"lldb::SBExpressionOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_GetFetchDynamicValue",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (lldb::DynamicValueType)((lldb::SBExpressionOptions const *)arg1)->GetFetchDynamicValue();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetFetchDynamicValue__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
lldb::DynamicValueType arg2 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetFetchDynamicValue",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetFetchDynamicValue",1,"lldb::SBExpressionOptions *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetFetchDynamicValue",2,"lldb::DynamicValueType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetFetchDynamicValue",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
arg2 = (lldb::DynamicValueType)lua_tointeger(L, 2);
(arg1)->SetFetchDynamicValue(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetFetchDynamicValue__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetFetchDynamicValue",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetFetchDynamicValue",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetFetchDynamicValue",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
(arg1)->SetFetchDynamicValue();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetFetchDynamicValue(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBExpressionOptions_SetFetchDynamicValue__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBExpressionOptions_SetFetchDynamicValue__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetFetchDynamicValue'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBExpressionOptions::SetFetchDynamicValue(lldb::DynamicValueType)\n"
" lldb::SBExpressionOptions::SetFetchDynamicValue()\n");
lua_error(L);return 0;
}
static int _wrap_SBExpressionOptions_GetTimeoutInMicroSeconds(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBExpressionOptions::GetTimeoutInMicroSeconds",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetTimeoutInMicroSeconds",1,"lldb::SBExpressionOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_GetTimeoutInMicroSeconds",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (uint32_t)((lldb::SBExpressionOptions const *)arg1)->GetTimeoutInMicroSeconds();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetTimeoutInMicroSeconds__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetTimeoutInMicroSeconds",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTimeoutInMicroSeconds",1,"lldb::SBExpressionOptions *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTimeoutInMicroSeconds",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetTimeoutInMicroSeconds",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetTimeoutInMicroSeconds(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetTimeoutInMicroSeconds__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetTimeoutInMicroSeconds",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTimeoutInMicroSeconds",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetTimeoutInMicroSeconds",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
(arg1)->SetTimeoutInMicroSeconds();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetTimeoutInMicroSeconds(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBExpressionOptions_SetTimeoutInMicroSeconds__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBExpressionOptions_SetTimeoutInMicroSeconds__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetTimeoutInMicroSeconds'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBExpressionOptions::SetTimeoutInMicroSeconds(uint32_t)\n"
" lldb::SBExpressionOptions::SetTimeoutInMicroSeconds()\n");
lua_error(L);return 0;
}
static int _wrap_SBExpressionOptions_GetOneThreadTimeoutInMicroSeconds(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds",1,"lldb::SBExpressionOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_GetOneThreadTimeoutInMicroSeconds",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (uint32_t)((lldb::SBExpressionOptions const *)arg1)->GetOneThreadTimeoutInMicroSeconds();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds",1,"lldb::SBExpressionOptions *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetOneThreadTimeoutInMicroSeconds(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
(arg1)->SetOneThreadTimeoutInMicroSeconds();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t)\n"
" lldb::SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds()\n");
lua_error(L);return 0;
}
static int _wrap_SBExpressionOptions_GetTryAllThreads(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBExpressionOptions::GetTryAllThreads",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetTryAllThreads",1,"lldb::SBExpressionOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_GetTryAllThreads",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (bool)((lldb::SBExpressionOptions const *)arg1)->GetTryAllThreads();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetTryAllThreads__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetTryAllThreads",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTryAllThreads",1,"lldb::SBExpressionOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTryAllThreads",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetTryAllThreads",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetTryAllThreads(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetTryAllThreads__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetTryAllThreads",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTryAllThreads",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetTryAllThreads",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
(arg1)->SetTryAllThreads();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetTryAllThreads(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBExpressionOptions_SetTryAllThreads__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_SBExpressionOptions_SetTryAllThreads__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetTryAllThreads'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBExpressionOptions::SetTryAllThreads(bool)\n"
" lldb::SBExpressionOptions::SetTryAllThreads()\n");
lua_error(L);return 0;
}
static int _wrap_SBExpressionOptions_GetStopOthers(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBExpressionOptions::GetStopOthers",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetStopOthers",1,"lldb::SBExpressionOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_GetStopOthers",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (bool)((lldb::SBExpressionOptions const *)arg1)->GetStopOthers();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetStopOthers__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetStopOthers",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetStopOthers",1,"lldb::SBExpressionOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetStopOthers",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetStopOthers",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetStopOthers(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetStopOthers__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetStopOthers",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetStopOthers",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetStopOthers",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
(arg1)->SetStopOthers();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetStopOthers(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBExpressionOptions_SetStopOthers__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_SBExpressionOptions_SetStopOthers__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetStopOthers'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBExpressionOptions::SetStopOthers(bool)\n"
" lldb::SBExpressionOptions::SetStopOthers()\n");
lua_error(L);return 0;
}
static int _wrap_SBExpressionOptions_GetTrapExceptions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBExpressionOptions::GetTrapExceptions",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetTrapExceptions",1,"lldb::SBExpressionOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_GetTrapExceptions",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (bool)((lldb::SBExpressionOptions const *)arg1)->GetTrapExceptions();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetTrapExceptions__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetTrapExceptions",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTrapExceptions",1,"lldb::SBExpressionOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTrapExceptions",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetTrapExceptions",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetTrapExceptions(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetTrapExceptions__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetTrapExceptions",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTrapExceptions",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetTrapExceptions",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
(arg1)->SetTrapExceptions();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetTrapExceptions(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBExpressionOptions_SetTrapExceptions__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_SBExpressionOptions_SetTrapExceptions__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetTrapExceptions'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBExpressionOptions::SetTrapExceptions(bool)\n"
" lldb::SBExpressionOptions::SetTrapExceptions()\n");
lua_error(L);return 0;
}
static int _wrap_SBExpressionOptions_SetLanguage(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
lldb::LanguageType arg2 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetLanguage",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetLanguage",1,"lldb::SBExpressionOptions *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetLanguage",2,"lldb::LanguageType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetLanguage",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
arg2 = (lldb::LanguageType)lua_tointeger(L, 2);
(arg1)->SetLanguage(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_GetGenerateDebugInfo(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBExpressionOptions::GetGenerateDebugInfo",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetGenerateDebugInfo",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_GetGenerateDebugInfo",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (bool)(arg1)->GetGenerateDebugInfo();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetGenerateDebugInfo__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetGenerateDebugInfo",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetGenerateDebugInfo",1,"lldb::SBExpressionOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetGenerateDebugInfo",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetGenerateDebugInfo",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetGenerateDebugInfo(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetGenerateDebugInfo__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetGenerateDebugInfo",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetGenerateDebugInfo",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetGenerateDebugInfo",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
(arg1)->SetGenerateDebugInfo();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetGenerateDebugInfo(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBExpressionOptions_SetGenerateDebugInfo__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_SBExpressionOptions_SetGenerateDebugInfo__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetGenerateDebugInfo'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBExpressionOptions::SetGenerateDebugInfo(bool)\n"
" lldb::SBExpressionOptions::SetGenerateDebugInfo()\n");
lua_error(L);return 0;
}
static int _wrap_SBExpressionOptions_GetSuppressPersistentResult(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBExpressionOptions::GetSuppressPersistentResult",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetSuppressPersistentResult",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_GetSuppressPersistentResult",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (bool)(arg1)->GetSuppressPersistentResult();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetSuppressPersistentResult__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetSuppressPersistentResult",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetSuppressPersistentResult",1,"lldb::SBExpressionOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetSuppressPersistentResult",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetSuppressPersistentResult",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetSuppressPersistentResult(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetSuppressPersistentResult__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetSuppressPersistentResult",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetSuppressPersistentResult",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetSuppressPersistentResult",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
(arg1)->SetSuppressPersistentResult();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetSuppressPersistentResult(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBExpressionOptions_SetSuppressPersistentResult__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_SBExpressionOptions_SetSuppressPersistentResult__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetSuppressPersistentResult'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBExpressionOptions::SetSuppressPersistentResult(bool)\n"
" lldb::SBExpressionOptions::SetSuppressPersistentResult()\n");
lua_error(L);return 0;
}
static int _wrap_SBExpressionOptions_GetPrefix(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBExpressionOptions::GetPrefix",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetPrefix",1,"lldb::SBExpressionOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_GetPrefix",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (char *)((lldb::SBExpressionOptions const *)arg1)->GetPrefix();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetPrefix(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetPrefix",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetPrefix",1,"lldb::SBExpressionOptions *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetPrefix",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetPrefix",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetPrefix((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetAutoApplyFixIts__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetAutoApplyFixIts",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetAutoApplyFixIts",1,"lldb::SBExpressionOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetAutoApplyFixIts",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetAutoApplyFixIts",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetAutoApplyFixIts(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetAutoApplyFixIts__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetAutoApplyFixIts",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetAutoApplyFixIts",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetAutoApplyFixIts",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
(arg1)->SetAutoApplyFixIts();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetAutoApplyFixIts(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBExpressionOptions_SetAutoApplyFixIts__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_SBExpressionOptions_SetAutoApplyFixIts__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetAutoApplyFixIts'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBExpressionOptions::SetAutoApplyFixIts(bool)\n"
" lldb::SBExpressionOptions::SetAutoApplyFixIts()\n");
lua_error(L);return 0;
}
static int _wrap_SBExpressionOptions_GetAutoApplyFixIts(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBExpressionOptions::GetAutoApplyFixIts",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetAutoApplyFixIts",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_GetAutoApplyFixIts",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (bool)(arg1)->GetAutoApplyFixIts();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetRetriesWithFixIts(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
uint64_t arg2 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetRetriesWithFixIts",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetRetriesWithFixIts",1,"lldb::SBExpressionOptions *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetRetriesWithFixIts",2,"uint64_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetRetriesWithFixIts",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
arg2 = (uint64_t)lua_tointeger(L, 2);
(arg1)->SetRetriesWithFixIts(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_GetRetriesWithFixIts(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
uint64_t result;
SWIG_check_num_args("lldb::SBExpressionOptions::GetRetriesWithFixIts",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetRetriesWithFixIts",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_GetRetriesWithFixIts",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (uint64_t)(arg1)->GetRetriesWithFixIts();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_GetTopLevel(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBExpressionOptions::GetTopLevel",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetTopLevel",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_GetTopLevel",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (bool)(arg1)->GetTopLevel();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetTopLevel__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetTopLevel",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTopLevel",1,"lldb::SBExpressionOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTopLevel",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetTopLevel",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetTopLevel(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetTopLevel__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetTopLevel",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTopLevel",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetTopLevel",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
(arg1)->SetTopLevel();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetTopLevel(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBExpressionOptions_SetTopLevel__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_SBExpressionOptions_SetTopLevel__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetTopLevel'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBExpressionOptions::SetTopLevel(bool)\n"
" lldb::SBExpressionOptions::SetTopLevel()\n");
lua_error(L);return 0;
}
static int _wrap_SBExpressionOptions_GetAllowJIT(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBExpressionOptions::GetAllowJIT",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetAllowJIT",1,"lldb::SBExpressionOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_GetAllowJIT",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (bool)(arg1)->GetAllowJIT();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBExpressionOptions_SetAllowJIT(lua_State* L) {
int SWIG_arg = 0;
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBExpressionOptions::SetAllowJIT",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetAllowJIT",1,"lldb::SBExpressionOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetAllowJIT",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBExpressionOptions_SetAllowJIT",1,SWIGTYPE_p_lldb__SBExpressionOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetAllowJIT(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBExpressionOptions(void *obj) {
lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBExpressionOptions(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBExpressionOptions);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBExpressionOptions_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBExpressionOptions_methods[]= {
{ "GetCoerceResultToId", _wrap_SBExpressionOptions_GetCoerceResultToId},
{ "SetCoerceResultToId", _wrap_SBExpressionOptions_SetCoerceResultToId},
{ "GetUnwindOnError", _wrap_SBExpressionOptions_GetUnwindOnError},
{ "SetUnwindOnError", _wrap_SBExpressionOptions_SetUnwindOnError},
{ "GetIgnoreBreakpoints", _wrap_SBExpressionOptions_GetIgnoreBreakpoints},
{ "SetIgnoreBreakpoints", _wrap_SBExpressionOptions_SetIgnoreBreakpoints},
{ "GetFetchDynamicValue", _wrap_SBExpressionOptions_GetFetchDynamicValue},
{ "SetFetchDynamicValue", _wrap_SBExpressionOptions_SetFetchDynamicValue},
{ "GetTimeoutInMicroSeconds", _wrap_SBExpressionOptions_GetTimeoutInMicroSeconds},
{ "SetTimeoutInMicroSeconds", _wrap_SBExpressionOptions_SetTimeoutInMicroSeconds},
{ "GetOneThreadTimeoutInMicroSeconds", _wrap_SBExpressionOptions_GetOneThreadTimeoutInMicroSeconds},
{ "SetOneThreadTimeoutInMicroSeconds", _wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds},
{ "GetTryAllThreads", _wrap_SBExpressionOptions_GetTryAllThreads},
{ "SetTryAllThreads", _wrap_SBExpressionOptions_SetTryAllThreads},
{ "GetStopOthers", _wrap_SBExpressionOptions_GetStopOthers},
{ "SetStopOthers", _wrap_SBExpressionOptions_SetStopOthers},
{ "GetTrapExceptions", _wrap_SBExpressionOptions_GetTrapExceptions},
{ "SetTrapExceptions", _wrap_SBExpressionOptions_SetTrapExceptions},
{ "SetLanguage", _wrap_SBExpressionOptions_SetLanguage},
{ "GetGenerateDebugInfo", _wrap_SBExpressionOptions_GetGenerateDebugInfo},
{ "SetGenerateDebugInfo", _wrap_SBExpressionOptions_SetGenerateDebugInfo},
{ "GetSuppressPersistentResult", _wrap_SBExpressionOptions_GetSuppressPersistentResult},
{ "SetSuppressPersistentResult", _wrap_SBExpressionOptions_SetSuppressPersistentResult},
{ "GetPrefix", _wrap_SBExpressionOptions_GetPrefix},
{ "SetPrefix", _wrap_SBExpressionOptions_SetPrefix},
{ "SetAutoApplyFixIts", _wrap_SBExpressionOptions_SetAutoApplyFixIts},
{ "GetAutoApplyFixIts", _wrap_SBExpressionOptions_GetAutoApplyFixIts},
{ "SetRetriesWithFixIts", _wrap_SBExpressionOptions_SetRetriesWithFixIts},
{ "GetRetriesWithFixIts", _wrap_SBExpressionOptions_GetRetriesWithFixIts},
{ "GetTopLevel", _wrap_SBExpressionOptions_GetTopLevel},
{ "SetTopLevel", _wrap_SBExpressionOptions_SetTopLevel},
{ "GetAllowJIT", _wrap_SBExpressionOptions_GetAllowJIT},
{ "SetAllowJIT", _wrap_SBExpressionOptions_SetAllowJIT},
{0,0}
};
static swig_lua_method swig_SBExpressionOptions_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBExpressionOptions_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBExpressionOptions_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBExpressionOptions_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBExpressionOptions_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBExpressionOptions_Sf_SwigStatic = {
"SBExpressionOptions",
swig_SBExpressionOptions_Sf_SwigStatic_methods,
swig_SBExpressionOptions_Sf_SwigStatic_attributes,
swig_SBExpressionOptions_Sf_SwigStatic_constants,
swig_SBExpressionOptions_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBExpressionOptions_bases[] = {0};
static const char *swig_SBExpressionOptions_base_names[] = {0};
static swig_lua_class _wrap_class_SBExpressionOptions = { "SBExpressionOptions", "SBExpressionOptions", &SWIGTYPE_p_lldb__SBExpressionOptions,_proxy__wrap_new_SBExpressionOptions, swig_delete_SBExpressionOptions, swig_SBExpressionOptions_methods, swig_SBExpressionOptions_attributes, &swig_SBExpressionOptions_Sf_SwigStatic, swig_SBExpressionOptions_meta, swig_SBExpressionOptions_bases, swig_SBExpressionOptions_base_names };
static int _wrap_new_SBFile__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFile *result = 0 ;
SWIG_check_num_args("lldb::SBFile::SBFile",0,0)
result = (lldb::SBFile *)new lldb::SBFile();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFile,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBFile__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
int arg1 ;
char *arg2 = (char *) 0 ;
bool arg3 ;
lldb::SBFile *result = 0 ;
SWIG_check_num_args("lldb::SBFile::SBFile",3,3)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBFile::SBFile",1,"int");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFile::SBFile",2,"char const *");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBFile::SBFile",3,"bool");
arg1 = (int)lua_tointeger(L, 1);
arg2 = (char *)lua_tostring(L, 2);
arg3 = (lua_toboolean(L, 3)!=0);
result = (lldb::SBFile *)new lldb::SBFile(arg1,(char const *)arg2,arg3);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFile,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBFile__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg1 ;
lldb::SBFile *result = 0 ;
SWIG_check_num_args("lldb::SBFile::SBFile",1,1)
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 1, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg1 = file_sp;
}
result = (lldb::SBFile *)new lldb::SBFile(arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFile,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBFile(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBFile__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
_v = (lua_isuserdata(L, argv[0])) &&
(luaL_testudata(L, argv[0], LUA_FILEHANDLE) != nullptr);
}
if (_v) {
return _wrap_new_SBFile__SWIG_2(L);
}
}
if (argc == 3) {
int _v;
{
_v = lua_isnumber(L,argv[0]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[2]);
}
if (_v) {
return _wrap_new_SBFile__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBFile'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBFile::SBFile()\n"
" lldb::SBFile::SBFile(int,char const *,bool)\n"
" lldb::SBFile::SBFile(lldb::FileSP)\n");
lua_error(L);return 0;
}
static int _wrap_SBFile_MakeBorrowed(lua_State* L) {
int SWIG_arg = 0;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg1 ;
lldb::SBFile result;
SWIG_check_num_args("lldb::SBFile::lldb_SBFile_MakeBorrowed",1,1)
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 1, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg1 = file_sp;
}
result = lldb_SBFile_MakeBorrowed(arg1);
{
lldb::SBFile * resultptr = new lldb::SBFile((const lldb::SBFile &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFile,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFile_MakeForcingIOMethods(lua_State* L) {
int SWIG_arg = 0;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg1 ;
lldb::SBFile result;
SWIG_check_num_args("lldb::SBFile::lldb_SBFile_MakeForcingIOMethods",1,1)
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 1, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg1 = file_sp;
}
result = lldb_SBFile_MakeForcingIOMethods(arg1);
{
lldb::SBFile * resultptr = new lldb::SBFile((const lldb::SBFile &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFile,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFile_MakeBorrowedForcingIOMethods(lua_State* L) {
int SWIG_arg = 0;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg1 ;
lldb::SBFile result;
SWIG_check_num_args("lldb::SBFile::lldb_SBFile_MakeBorrowedForcingIOMethods",1,1)
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 1, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg1 = file_sp;
}
result = lldb_SBFile_MakeBorrowedForcingIOMethods(arg1);
{
lldb::SBFile * resultptr = new lldb::SBFile((const lldb::SBFile &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFile,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFile_Read(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFile *arg1 = (lldb::SBFile *) 0 ;
uint8_t *arg2 = (uint8_t *) 0 ;
size_t arg3 ;
size_t *arg4 = (size_t *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBFile::Read",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFile::Read",1,"lldb::SBFile *");
if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBFile::Read",2,"uint8_t *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFile::Read",3,"size_t");
if(!SWIG_isptrtype(L,4)) SWIG_fail_arg("lldb::SBFile::Read",4,"size_t *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBFile_Read",1,SWIGTYPE_p_lldb__SBFile);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){
SWIG_fail_ptr("SBFile_Read",2,SWIGTYPE_p_unsigned_char);
}
arg3 = (size_t)lua_tointeger(L, 3);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_size_t,0))){
SWIG_fail_ptr("SBFile_Read",4,SWIGTYPE_p_size_t);
}
result = (arg1)->Read(arg2,arg3,arg4);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFile_Write(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFile *arg1 = (lldb::SBFile *) 0 ;
uint8_t *arg2 = (uint8_t *) 0 ;
size_t arg3 ;
size_t *arg4 = (size_t *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBFile::Write",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFile::Write",1,"lldb::SBFile *");
if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBFile::Write",2,"uint8_t const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFile::Write",3,"size_t");
if(!SWIG_isptrtype(L,4)) SWIG_fail_arg("lldb::SBFile::Write",4,"size_t *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBFile_Write",1,SWIGTYPE_p_lldb__SBFile);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){
SWIG_fail_ptr("SBFile_Write",2,SWIGTYPE_p_unsigned_char);
}
arg3 = (size_t)lua_tointeger(L, 3);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_size_t,0))){
SWIG_fail_ptr("SBFile_Write",4,SWIGTYPE_p_size_t);
}
result = (arg1)->Write((uint8_t const *)arg2,arg3,arg4);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFile_Flush(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFile *arg1 = (lldb::SBFile *) 0 ;
SWIG_check_num_args("lldb::SBFile::Flush",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFile::Flush",1,"lldb::SBFile *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBFile_Flush",1,SWIGTYPE_p_lldb__SBFile);
}
(arg1)->Flush();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFile_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFile *arg1 = (lldb::SBFile *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBFile::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFile::IsValid",1,"lldb::SBFile const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBFile_IsValid",1,SWIGTYPE_p_lldb__SBFile);
}
result = (bool)((lldb::SBFile const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFile_Close(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFile *arg1 = (lldb::SBFile *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBFile::Close",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFile::Close",1,"lldb::SBFile *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBFile_Close",1,SWIGTYPE_p_lldb__SBFile);
}
result = (arg1)->Close();
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFile_GetFile(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFile *arg1 = (lldb::SBFile *) 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > result;
SWIG_check_num_args("lldb::SBFile::GetFile",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFile::GetFile",1,"lldb::SBFile *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBFile_GetFile",1,SWIGTYPE_p_lldb__SBFile);
}
result = (arg1)->GetFile();
{
lldb::FileSP &sp = result;
if (sp && sp->IsValid()) {
luaL_Stream *p = (luaL_Stream *)lua_newuserdata(L, sizeof(luaL_Stream));
p->closef = &LLDBSwigLuaCloseFileHandle;
p->f = sp->GetStream();
luaL_setmetatable(L, LUA_FILEHANDLE);
SWIG_arg++;
}
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBFile(void *obj) {
lldb::SBFile *arg1 = (lldb::SBFile *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBFile(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBFile);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBFile_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBFile_methods[]= {
{ "Read", _wrap_SBFile_Read},
{ "Write", _wrap_SBFile_Write},
{ "Flush", _wrap_SBFile_Flush},
{ "IsValid", _wrap_SBFile_IsValid},
{ "Close", _wrap_SBFile_Close},
{ "GetFile", _wrap_SBFile_GetFile},
{0,0}
};
static swig_lua_method swig_SBFile_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBFile_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBFile_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBFile_Sf_SwigStatic_methods[]= {
{ "MakeBorrowed", _wrap_SBFile_MakeBorrowed},
{ "MakeForcingIOMethods", _wrap_SBFile_MakeForcingIOMethods},
{ "MakeBorrowedForcingIOMethods", _wrap_SBFile_MakeBorrowedForcingIOMethods},
{0,0}
};
static swig_lua_class* swig_SBFile_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBFile_Sf_SwigStatic = {
"SBFile",
swig_SBFile_Sf_SwigStatic_methods,
swig_SBFile_Sf_SwigStatic_attributes,
swig_SBFile_Sf_SwigStatic_constants,
swig_SBFile_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBFile_bases[] = {0};
static const char *swig_SBFile_base_names[] = {0};
static swig_lua_class _wrap_class_SBFile = { "SBFile", "SBFile", &SWIGTYPE_p_lldb__SBFile,_proxy__wrap_new_SBFile, swig_delete_SBFile, swig_SBFile_methods, swig_SBFile_attributes, &swig_SBFile_Sf_SwigStatic, swig_SBFile_meta, swig_SBFile_bases, swig_SBFile_base_names };
static int _wrap_new_SBFileSpec__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpec *result = 0 ;
SWIG_check_num_args("lldb::SBFileSpec::SBFileSpec",0,0)
result = (lldb::SBFileSpec *)new lldb::SBFileSpec();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBFileSpec__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpec *arg1 = 0 ;
lldb::SBFileSpec *result = 0 ;
SWIG_check_num_args("lldb::SBFileSpec::SBFileSpec",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBFileSpec::SBFileSpec",1,"lldb::SBFileSpec const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("new_SBFileSpec",1,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (lldb::SBFileSpec *)new lldb::SBFileSpec((lldb::SBFileSpec const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBFileSpec__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
lldb::SBFileSpec *result = 0 ;
SWIG_check_num_args("lldb::SBFileSpec::SBFileSpec",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBFileSpec::SBFileSpec",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = (lldb::SBFileSpec *)new lldb::SBFileSpec((char const *)arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBFileSpec__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
bool arg2 ;
lldb::SBFileSpec *result = 0 ;
SWIG_check_num_args("lldb::SBFileSpec::SBFileSpec",2,2)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBFileSpec::SBFileSpec",1,"char const *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBFileSpec::SBFileSpec",2,"bool");
arg1 = (char *)lua_tostring(L, 1);
arg2 = (lua_toboolean(L, 2)!=0);
result = (lldb::SBFileSpec *)new lldb::SBFileSpec((char const *)arg1,arg2);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBFileSpec(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBFileSpec__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBFileSpec__SWIG_1(L);
}
}
if (argc == 1) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
return _wrap_new_SBFileSpec__SWIG_2(L);
}
}
if (argc == 2) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_new_SBFileSpec__SWIG_3(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBFileSpec'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBFileSpec::SBFileSpec()\n"
" lldb::SBFileSpec::SBFileSpec(lldb::SBFileSpec const &)\n"
" lldb::SBFileSpec::SBFileSpec(char const *)\n"
" lldb::SBFileSpec::SBFileSpec(char const *,bool)\n");
lua_error(L);return 0;
}
static int _wrap_SBFileSpec___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBFileSpec::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::operator ==",1,"lldb::SBFileSpec const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFileSpec::operator ==",2,"lldb::SBFileSpec const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBFileSpec___eq",1,SWIGTYPE_p_lldb__SBFileSpec);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBFileSpec___eq",2,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (bool)((lldb::SBFileSpec const *)arg1)->operator ==((lldb::SBFileSpec const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFileSpec_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBFileSpec::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::IsValid",1,"lldb::SBFileSpec const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBFileSpec_IsValid",1,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (bool)((lldb::SBFileSpec const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFileSpec_Exists(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBFileSpec::Exists",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::Exists",1,"lldb::SBFileSpec const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBFileSpec_Exists",1,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (bool)((lldb::SBFileSpec const *)arg1)->Exists();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFileSpec_ResolveExecutableLocation(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBFileSpec::ResolveExecutableLocation",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::ResolveExecutableLocation",1,"lldb::SBFileSpec *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBFileSpec_ResolveExecutableLocation",1,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (bool)(arg1)->ResolveExecutableLocation();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFileSpec_GetFilename(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBFileSpec::GetFilename",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::GetFilename",1,"lldb::SBFileSpec const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBFileSpec_GetFilename",1,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (char *)((lldb::SBFileSpec const *)arg1)->GetFilename();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFileSpec_GetDirectory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBFileSpec::GetDirectory",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::GetDirectory",1,"lldb::SBFileSpec const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBFileSpec_GetDirectory",1,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (char *)((lldb::SBFileSpec const *)arg1)->GetDirectory();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFileSpec_SetFilename(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBFileSpec::SetFilename",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::SetFilename",1,"lldb::SBFileSpec *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFileSpec::SetFilename",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBFileSpec_SetFilename",1,SWIGTYPE_p_lldb__SBFileSpec);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetFilename((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFileSpec_SetDirectory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBFileSpec::SetDirectory",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::SetDirectory",1,"lldb::SBFileSpec *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFileSpec::SetDirectory",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBFileSpec_SetDirectory",1,SWIGTYPE_p_lldb__SBFileSpec);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetDirectory((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFileSpec_GetPath(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ;
char *arg2 = (char *) 0 ;
size_t arg3 ;
uint32_t result;
SWIG_check_num_args("lldb::SBFileSpec::GetPath",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::GetPath",1,"lldb::SBFileSpec const *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFileSpec::GetPath",2,"char *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFileSpec::GetPath",3,"size_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBFileSpec_GetPath",1,SWIGTYPE_p_lldb__SBFileSpec);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (size_t)lua_tointeger(L, 3);
result = (uint32_t)((lldb::SBFileSpec const *)arg1)->GetPath(arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFileSpec_ResolvePath(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
char *arg2 = (char *) 0 ;
size_t arg3 ;
int result;
SWIG_check_num_args("lldb::SBFileSpec::ResolvePath",3,3)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBFileSpec::ResolvePath",1,"char const *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFileSpec::ResolvePath",2,"char *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFileSpec::ResolvePath",3,"size_t");
arg1 = (char *)lua_tostring(L, 1);
arg2 = (char *)lua_tostring(L, 2);
arg3 = (size_t)lua_tointeger(L, 3);
result = (int)lldb::SBFileSpec::ResolvePath((char const *)arg1,arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFileSpec_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBFileSpec::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::GetDescription",1,"lldb::SBFileSpec const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFileSpec::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBFileSpec_GetDescription",1,SWIGTYPE_p_lldb__SBFileSpec);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBFileSpec_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)((lldb::SBFileSpec const *)arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFileSpec_AppendPathComponent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBFileSpec::AppendPathComponent",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::AppendPathComponent",1,"lldb::SBFileSpec *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFileSpec::AppendPathComponent",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBFileSpec_AppendPathComponent",1,SWIGTYPE_p_lldb__SBFileSpec);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->AppendPathComponent((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFileSpec___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBFileSpec::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::__str__",1,"lldb::SBFileSpec *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBFileSpec___tostring",1,SWIGTYPE_p_lldb__SBFileSpec);
}
result = lldb_SBFileSpec___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBFileSpec(void *obj) {
lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBFileSpec(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBFileSpec);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBFileSpec_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBFileSpec_methods[]= {
{ "__eq", _wrap_SBFileSpec___eq},
{ "IsValid", _wrap_SBFileSpec_IsValid},
{ "Exists", _wrap_SBFileSpec_Exists},
{ "ResolveExecutableLocation", _wrap_SBFileSpec_ResolveExecutableLocation},
{ "GetFilename", _wrap_SBFileSpec_GetFilename},
{ "GetDirectory", _wrap_SBFileSpec_GetDirectory},
{ "SetFilename", _wrap_SBFileSpec_SetFilename},
{ "SetDirectory", _wrap_SBFileSpec_SetDirectory},
{ "GetPath", _wrap_SBFileSpec_GetPath},
{ "GetDescription", _wrap_SBFileSpec_GetDescription},
{ "AppendPathComponent", _wrap_SBFileSpec_AppendPathComponent},
{ "__tostring", _wrap_SBFileSpec___tostring},
{0,0}
};
static swig_lua_method swig_SBFileSpec_meta[] = {
{ "__eq", _wrap_SBFileSpec___eq},
{ "__tostring", _wrap_SBFileSpec___tostring},
{0,0}
};
static swig_lua_attribute swig_SBFileSpec_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBFileSpec_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBFileSpec_Sf_SwigStatic_methods[]= {
{ "ResolvePath", _wrap_SBFileSpec_ResolvePath},
{0,0}
};
static swig_lua_class* swig_SBFileSpec_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBFileSpec_Sf_SwigStatic = {
"SBFileSpec",
swig_SBFileSpec_Sf_SwigStatic_methods,
swig_SBFileSpec_Sf_SwigStatic_attributes,
swig_SBFileSpec_Sf_SwigStatic_constants,
swig_SBFileSpec_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBFileSpec_bases[] = {0};
static const char *swig_SBFileSpec_base_names[] = {0};
static swig_lua_class _wrap_class_SBFileSpec = { "SBFileSpec", "SBFileSpec", &SWIGTYPE_p_lldb__SBFileSpec,_proxy__wrap_new_SBFileSpec, swig_delete_SBFileSpec, swig_SBFileSpec_methods, swig_SBFileSpec_attributes, &swig_SBFileSpec_Sf_SwigStatic, swig_SBFileSpec_meta, swig_SBFileSpec_bases, swig_SBFileSpec_base_names };
static int _wrap_new_SBFileSpecList__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpecList *result = 0 ;
SWIG_check_num_args("lldb::SBFileSpecList::SBFileSpecList",0,0)
result = (lldb::SBFileSpecList *)new lldb::SBFileSpecList();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFileSpecList,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBFileSpecList__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpecList *arg1 = 0 ;
lldb::SBFileSpecList *result = 0 ;
SWIG_check_num_args("lldb::SBFileSpecList::SBFileSpecList",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBFileSpecList::SBFileSpecList",1,"lldb::SBFileSpecList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("new_SBFileSpecList",1,SWIGTYPE_p_lldb__SBFileSpecList);
}
result = (lldb::SBFileSpecList *)new lldb::SBFileSpecList((lldb::SBFileSpecList const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFileSpecList,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBFileSpecList(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBFileSpecList__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBFileSpecList__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBFileSpecList'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBFileSpecList::SBFileSpecList()\n"
" lldb::SBFileSpecList::SBFileSpecList(lldb::SBFileSpecList const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBFileSpecList_GetSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBFileSpecList::GetSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpecList::GetSize",1,"lldb::SBFileSpecList const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBFileSpecList_GetSize",1,SWIGTYPE_p_lldb__SBFileSpecList);
}
result = (uint32_t)((lldb::SBFileSpecList const *)arg1)->GetSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFileSpecList_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBFileSpecList::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpecList::GetDescription",1,"lldb::SBFileSpecList const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFileSpecList::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBFileSpecList_GetDescription",1,SWIGTYPE_p_lldb__SBFileSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBFileSpecList_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)((lldb::SBFileSpecList const *)arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFileSpecList_Append(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
SWIG_check_num_args("lldb::SBFileSpecList::Append",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpecList::Append",1,"lldb::SBFileSpecList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFileSpecList::Append",2,"lldb::SBFileSpec const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBFileSpecList_Append",1,SWIGTYPE_p_lldb__SBFileSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBFileSpecList_Append",2,SWIGTYPE_p_lldb__SBFileSpec);
}
(arg1)->Append((lldb::SBFileSpec const &)*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFileSpecList_AppendIfUnique(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBFileSpecList::AppendIfUnique",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpecList::AppendIfUnique",1,"lldb::SBFileSpecList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFileSpecList::AppendIfUnique",2,"lldb::SBFileSpec const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBFileSpecList_AppendIfUnique",1,SWIGTYPE_p_lldb__SBFileSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBFileSpecList_AppendIfUnique",2,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (bool)(arg1)->AppendIfUnique((lldb::SBFileSpec const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFileSpecList_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ;
SWIG_check_num_args("lldb::SBFileSpecList::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpecList::Clear",1,"lldb::SBFileSpecList *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBFileSpecList_Clear",1,SWIGTYPE_p_lldb__SBFileSpecList);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFileSpecList_FindFileIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ;
uint32_t arg2 ;
lldb::SBFileSpec *arg3 = 0 ;
bool arg4 ;
uint32_t result;
SWIG_check_num_args("lldb::SBFileSpecList::FindFileIndex",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpecList::FindFileIndex",1,"lldb::SBFileSpecList *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBFileSpecList::FindFileIndex",2,"uint32_t");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBFileSpecList::FindFileIndex",3,"lldb::SBFileSpec const &");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBFileSpecList::FindFileIndex",4,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBFileSpecList_FindFileIndex",1,SWIGTYPE_p_lldb__SBFileSpecList);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBFileSpecList_FindFileIndex",3,SWIGTYPE_p_lldb__SBFileSpec);
}
arg4 = (lua_toboolean(L, 4)!=0);
result = (uint32_t)(arg1)->FindFileIndex(arg2,(lldb::SBFileSpec const &)*arg3,arg4);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFileSpecList_GetFileSpecAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ;
uint32_t arg2 ;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBFileSpecList::GetFileSpecAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpecList::GetFileSpecAtIndex",1,"lldb::SBFileSpecList const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBFileSpecList::GetFileSpecAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBFileSpecList_GetFileSpecAtIndex",1,SWIGTYPE_p_lldb__SBFileSpecList);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = ((lldb::SBFileSpecList const *)arg1)->GetFileSpecAtIndex(arg2);
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBFileSpecList(void *obj) {
lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBFileSpecList(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBFileSpecList);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBFileSpecList_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBFileSpecList_methods[]= {
{ "GetSize", _wrap_SBFileSpecList_GetSize},
{ "GetDescription", _wrap_SBFileSpecList_GetDescription},
{ "Append", _wrap_SBFileSpecList_Append},
{ "AppendIfUnique", _wrap_SBFileSpecList_AppendIfUnique},
{ "Clear", _wrap_SBFileSpecList_Clear},
{ "FindFileIndex", _wrap_SBFileSpecList_FindFileIndex},
{ "GetFileSpecAtIndex", _wrap_SBFileSpecList_GetFileSpecAtIndex},
{0,0}
};
static swig_lua_method swig_SBFileSpecList_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBFileSpecList_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBFileSpecList_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBFileSpecList_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBFileSpecList_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBFileSpecList_Sf_SwigStatic = {
"SBFileSpecList",
swig_SBFileSpecList_Sf_SwigStatic_methods,
swig_SBFileSpecList_Sf_SwigStatic_attributes,
swig_SBFileSpecList_Sf_SwigStatic_constants,
swig_SBFileSpecList_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBFileSpecList_bases[] = {0};
static const char *swig_SBFileSpecList_base_names[] = {0};
static swig_lua_class _wrap_class_SBFileSpecList = { "SBFileSpecList", "SBFileSpecList", &SWIGTYPE_p_lldb__SBFileSpecList,_proxy__wrap_new_SBFileSpecList, swig_delete_SBFileSpecList, swig_SBFileSpecList_methods, swig_SBFileSpecList_attributes, &swig_SBFileSpecList_Sf_SwigStatic, swig_SBFileSpecList_meta, swig_SBFileSpecList_bases, swig_SBFileSpecList_base_names };
static int _wrap_new_SBFrame__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *result = 0 ;
SWIG_check_num_args("lldb::SBFrame::SBFrame",0,0)
result = (lldb::SBFrame *)new lldb::SBFrame();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFrame,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBFrame__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = 0 ;
lldb::SBFrame *result = 0 ;
SWIG_check_num_args("lldb::SBFrame::SBFrame",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBFrame::SBFrame",1,"lldb::SBFrame const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("new_SBFrame",1,SWIGTYPE_p_lldb__SBFrame);
}
result = (lldb::SBFrame *)new lldb::SBFrame((lldb::SBFrame const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFrame,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBFrame(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBFrame__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBFrame__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBFrame'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBFrame::SBFrame()\n"
" lldb::SBFrame::SBFrame(lldb::SBFrame const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBFrame_IsEqual(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::SBFrame *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBFrame::IsEqual",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::IsEqual",1,"lldb::SBFrame const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFrame::IsEqual",2,"lldb::SBFrame const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_IsEqual",1,SWIGTYPE_p_lldb__SBFrame);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_IsEqual",2,SWIGTYPE_p_lldb__SBFrame);
}
result = (bool)((lldb::SBFrame const *)arg1)->IsEqual((lldb::SBFrame const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBFrame::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::IsValid",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_IsValid",1,SWIGTYPE_p_lldb__SBFrame);
}
result = (bool)((lldb::SBFrame const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetFrameID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBFrame::GetFrameID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetFrameID",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetFrameID",1,SWIGTYPE_p_lldb__SBFrame);
}
result = (uint32_t)((lldb::SBFrame const *)arg1)->GetFrameID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetCFA(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBFrame::GetCFA",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetCFA",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetCFA",1,SWIGTYPE_p_lldb__SBFrame);
}
result = (lldb::addr_t)((lldb::SBFrame const *)arg1)->GetCFA();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetPC(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBFrame::GetPC",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetPC",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetPC",1,SWIGTYPE_p_lldb__SBFrame);
}
result = (lldb::addr_t)((lldb::SBFrame const *)arg1)->GetPC();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_SetPC(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::addr_t arg2 ;
bool result;
SWIG_check_num_args("lldb::SBFrame::SetPC",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::SetPC",1,"lldb::SBFrame *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBFrame::SetPC",2,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_SetPC",1,SWIGTYPE_p_lldb__SBFrame);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
result = (bool)(arg1)->SetPC(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetSP(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBFrame::GetSP",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetSP",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetSP",1,SWIGTYPE_p_lldb__SBFrame);
}
result = (lldb::addr_t)((lldb::SBFrame const *)arg1)->GetSP();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetFP(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBFrame::GetFP",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetFP",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetFP",1,SWIGTYPE_p_lldb__SBFrame);
}
result = (lldb::addr_t)((lldb::SBFrame const *)arg1)->GetFP();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetPCAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBFrame::GetPCAddress",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetPCAddress",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetPCAddress",1,SWIGTYPE_p_lldb__SBFrame);
}
result = ((lldb::SBFrame const *)arg1)->GetPCAddress();
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetSymbolContext(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
uint32_t arg2 ;
lldb::SBSymbolContext result;
SWIG_check_num_args("lldb::SBFrame::GetSymbolContext",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetSymbolContext",1,"lldb::SBFrame const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBFrame::GetSymbolContext",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetSymbolContext",1,SWIGTYPE_p_lldb__SBFrame);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = ((lldb::SBFrame const *)arg1)->GetSymbolContext(arg2);
{
lldb::SBSymbolContext * resultptr = new lldb::SBSymbolContext((const lldb::SBSymbolContext &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContext,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetModule(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::SBModule result;
SWIG_check_num_args("lldb::SBFrame::GetModule",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetModule",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetModule",1,SWIGTYPE_p_lldb__SBFrame);
}
result = ((lldb::SBFrame const *)arg1)->GetModule();
{
lldb::SBModule * resultptr = new lldb::SBModule((const lldb::SBModule &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetCompileUnit(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::SBCompileUnit result;
SWIG_check_num_args("lldb::SBFrame::GetCompileUnit",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetCompileUnit",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetCompileUnit",1,SWIGTYPE_p_lldb__SBFrame);
}
result = ((lldb::SBFrame const *)arg1)->GetCompileUnit();
{
lldb::SBCompileUnit * resultptr = new lldb::SBCompileUnit((const lldb::SBCompileUnit &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBCompileUnit,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetFunction(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::SBFunction result;
SWIG_check_num_args("lldb::SBFrame::GetFunction",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetFunction",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetFunction",1,SWIGTYPE_p_lldb__SBFrame);
}
result = ((lldb::SBFrame const *)arg1)->GetFunction();
{
lldb::SBFunction * resultptr = new lldb::SBFunction((const lldb::SBFunction &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFunction,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetSymbol(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::SBSymbol result;
SWIG_check_num_args("lldb::SBFrame::GetSymbol",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetSymbol",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetSymbol",1,SWIGTYPE_p_lldb__SBFrame);
}
result = ((lldb::SBFrame const *)arg1)->GetSymbol();
{
lldb::SBSymbol * resultptr = new lldb::SBSymbol((const lldb::SBSymbol &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbol,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetBlock(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::SBBlock result;
SWIG_check_num_args("lldb::SBFrame::GetBlock",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetBlock",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetBlock",1,SWIGTYPE_p_lldb__SBFrame);
}
result = ((lldb::SBFrame const *)arg1)->GetBlock();
{
lldb::SBBlock * resultptr = new lldb::SBBlock((const lldb::SBBlock &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetFunctionName__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBFrame::GetFunctionName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetFunctionName",1,"lldb::SBFrame *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetFunctionName",1,SWIGTYPE_p_lldb__SBFrame);
}
result = (char *)(arg1)->GetFunctionName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetDisplayFunctionName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBFrame::GetDisplayFunctionName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetDisplayFunctionName",1,"lldb::SBFrame *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetDisplayFunctionName",1,SWIGTYPE_p_lldb__SBFrame);
}
result = (char *)(arg1)->GetDisplayFunctionName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetFunctionName__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBFrame::GetFunctionName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetFunctionName",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetFunctionName",1,SWIGTYPE_p_lldb__SBFrame);
}
result = (char *)((lldb::SBFrame const *)arg1)->GetFunctionName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetFunctionName(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBFrame_GetFunctionName__SWIG_0(L);
}
}
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBFrame_GetFunctionName__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBFrame_GetFunctionName'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBFrame::GetFunctionName()\n"
" lldb::SBFrame::GetFunctionName() const\n");
lua_error(L);return 0;
}
static int _wrap_SBFrame_GuessLanguage(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::LanguageType result;
SWIG_check_num_args("lldb::SBFrame::GuessLanguage",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GuessLanguage",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GuessLanguage",1,SWIGTYPE_p_lldb__SBFrame);
}
result = (lldb::LanguageType)((lldb::SBFrame const *)arg1)->GuessLanguage();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_IsInlined__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBFrame::IsInlined",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::IsInlined",1,"lldb::SBFrame *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_IsInlined",1,SWIGTYPE_p_lldb__SBFrame);
}
result = (bool)(arg1)->IsInlined();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_IsInlined__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBFrame::IsInlined",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::IsInlined",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_IsInlined",1,SWIGTYPE_p_lldb__SBFrame);
}
result = (bool)((lldb::SBFrame const *)arg1)->IsInlined();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_IsInlined(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBFrame_IsInlined__SWIG_0(L);
}
}
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBFrame_IsInlined__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBFrame_IsInlined'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBFrame::IsInlined()\n"
" lldb::SBFrame::IsInlined() const\n");
lua_error(L);return 0;
}
static int _wrap_SBFrame_IsArtificial__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBFrame::IsArtificial",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::IsArtificial",1,"lldb::SBFrame *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_IsArtificial",1,SWIGTYPE_p_lldb__SBFrame);
}
result = (bool)(arg1)->IsArtificial();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_IsArtificial__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBFrame::IsArtificial",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::IsArtificial",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_IsArtificial",1,SWIGTYPE_p_lldb__SBFrame);
}
result = (bool)((lldb::SBFrame const *)arg1)->IsArtificial();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_IsArtificial(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBFrame_IsArtificial__SWIG_0(L);
}
}
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBFrame_IsArtificial__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBFrame_IsArtificial'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBFrame::IsArtificial()\n"
" lldb::SBFrame::IsArtificial() const\n");
lua_error(L);return 0;
}
static int _wrap_SBFrame_EvaluateExpression__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBFrame::EvaluateExpression",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",1,"lldb::SBFrame *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_EvaluateExpression",1,SWIGTYPE_p_lldb__SBFrame);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->EvaluateExpression((char const *)arg2);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_EvaluateExpression__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
char *arg2 = (char *) 0 ;
lldb::DynamicValueType arg3 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBFrame::EvaluateExpression",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",1,"lldb::SBFrame *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",3,"lldb::DynamicValueType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_EvaluateExpression",1,SWIGTYPE_p_lldb__SBFrame);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (lldb::DynamicValueType)lua_tointeger(L, 3);
result = (arg1)->EvaluateExpression((char const *)arg2,arg3);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_EvaluateExpression__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
char *arg2 = (char *) 0 ;
lldb::DynamicValueType arg3 ;
bool arg4 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBFrame::EvaluateExpression",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",1,"lldb::SBFrame *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",3,"lldb::DynamicValueType");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",4,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_EvaluateExpression",1,SWIGTYPE_p_lldb__SBFrame);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (lldb::DynamicValueType)lua_tointeger(L, 3);
arg4 = (lua_toboolean(L, 4)!=0);
result = (arg1)->EvaluateExpression((char const *)arg2,arg3,arg4);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_EvaluateExpression__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBExpressionOptions *arg3 = 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBFrame::EvaluateExpression",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",1,"lldb::SBFrame *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",3,"lldb::SBExpressionOptions &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_EvaluateExpression",1,SWIGTYPE_p_lldb__SBFrame);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBFrame_EvaluateExpression",3,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (arg1)->EvaluateExpression((char const *)arg2,*arg3);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_EvaluateExpression(lua_State* L) {
int argc;
int argv[5]={
1,2,3,4,5
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBFrame_EvaluateExpression__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBFrame_EvaluateExpression__SWIG_3(L);
}
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBFrame_EvaluateExpression__SWIG_1(L);
}
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[3]);
}
if (_v) {
return _wrap_SBFrame_EvaluateExpression__SWIG_2(L);
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBFrame_EvaluateExpression'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBFrame::EvaluateExpression(char const *)\n"
" lldb::SBFrame::EvaluateExpression(char const *,lldb::DynamicValueType)\n"
" lldb::SBFrame::EvaluateExpression(char const *,lldb::DynamicValueType,bool)\n"
" lldb::SBFrame::EvaluateExpression(char const *,lldb::SBExpressionOptions &)\n");
lua_error(L);return 0;
}
static int _wrap_SBFrame_GetFrameBlock(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::SBBlock result;
SWIG_check_num_args("lldb::SBFrame::GetFrameBlock",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetFrameBlock",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetFrameBlock",1,SWIGTYPE_p_lldb__SBFrame);
}
result = ((lldb::SBFrame const *)arg1)->GetFrameBlock();
{
lldb::SBBlock * resultptr = new lldb::SBBlock((const lldb::SBBlock &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetLineEntry(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::SBLineEntry result;
SWIG_check_num_args("lldb::SBFrame::GetLineEntry",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetLineEntry",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetLineEntry",1,SWIGTYPE_p_lldb__SBFrame);
}
result = ((lldb::SBFrame const *)arg1)->GetLineEntry();
{
lldb::SBLineEntry * resultptr = new lldb::SBLineEntry((const lldb::SBLineEntry &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBLineEntry,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetThread(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::SBThread result;
SWIG_check_num_args("lldb::SBFrame::GetThread",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetThread",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetThread",1,SWIGTYPE_p_lldb__SBFrame);
}
result = ((lldb::SBFrame const *)arg1)->GetThread();
{
lldb::SBThread * resultptr = new lldb::SBThread((const lldb::SBThread &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_Disassemble(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBFrame::Disassemble",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::Disassemble",1,"lldb::SBFrame const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_Disassemble",1,SWIGTYPE_p_lldb__SBFrame);
}
result = (char *)((lldb::SBFrame const *)arg1)->Disassemble();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
SWIG_check_num_args("lldb::SBFrame::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::Clear",1,"lldb::SBFrame *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_Clear",1,SWIGTYPE_p_lldb__SBFrame);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::SBFrame *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBFrame::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::operator ==",1,"lldb::SBFrame const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFrame::operator ==",2,"lldb::SBFrame const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame___eq",1,SWIGTYPE_p_lldb__SBFrame);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame___eq",2,SWIGTYPE_p_lldb__SBFrame);
}
result = (bool)((lldb::SBFrame const *)arg1)->operator ==((lldb::SBFrame const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetVariables__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
bool arg2 ;
bool arg3 ;
bool arg4 ;
bool arg5 ;
lldb::SBValueList result;
SWIG_check_num_args("lldb::SBFrame::GetVariables",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetVariables",1,"lldb::SBFrame *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBFrame::GetVariables",2,"bool");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBFrame::GetVariables",3,"bool");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBFrame::GetVariables",4,"bool");
if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBFrame::GetVariables",5,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetVariables",1,SWIGTYPE_p_lldb__SBFrame);
}
arg2 = (lua_toboolean(L, 2)!=0);
arg3 = (lua_toboolean(L, 3)!=0);
arg4 = (lua_toboolean(L, 4)!=0);
arg5 = (lua_toboolean(L, 5)!=0);
result = (arg1)->GetVariables(arg2,arg3,arg4,arg5);
{
lldb::SBValueList * resultptr = new lldb::SBValueList((const lldb::SBValueList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetVariables__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
bool arg2 ;
bool arg3 ;
bool arg4 ;
bool arg5 ;
lldb::DynamicValueType arg6 ;
lldb::SBValueList result;
SWIG_check_num_args("lldb::SBFrame::GetVariables",6,6)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetVariables",1,"lldb::SBFrame *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBFrame::GetVariables",2,"bool");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBFrame::GetVariables",3,"bool");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBFrame::GetVariables",4,"bool");
if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBFrame::GetVariables",5,"bool");
if(!lua_isinteger(L,6)) SWIG_fail_arg("lldb::SBFrame::GetVariables",6,"lldb::DynamicValueType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetVariables",1,SWIGTYPE_p_lldb__SBFrame);
}
arg2 = (lua_toboolean(L, 2)!=0);
arg3 = (lua_toboolean(L, 3)!=0);
arg4 = (lua_toboolean(L, 4)!=0);
arg5 = (lua_toboolean(L, 5)!=0);
arg6 = (lldb::DynamicValueType)lua_tointeger(L, 6);
result = (arg1)->GetVariables(arg2,arg3,arg4,arg5,arg6);
{
lldb::SBValueList * resultptr = new lldb::SBValueList((const lldb::SBValueList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetVariables__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::SBVariablesOptions *arg2 = 0 ;
lldb::SBValueList result;
SWIG_check_num_args("lldb::SBFrame::GetVariables",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetVariables",1,"lldb::SBFrame *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFrame::GetVariables",2,"lldb::SBVariablesOptions const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetVariables",1,SWIGTYPE_p_lldb__SBFrame);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBVariablesOptions,0))){
SWIG_fail_ptr("SBFrame_GetVariables",2,SWIGTYPE_p_lldb__SBVariablesOptions);
}
result = (arg1)->GetVariables((lldb::SBVariablesOptions const &)*arg2);
{
lldb::SBValueList * resultptr = new lldb::SBValueList((const lldb::SBValueList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetVariables(lua_State* L) {
int argc;
int argv[7]={
1,2,3,4,5,6,7
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBVariablesOptions, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBFrame_GetVariables__SWIG_2(L);
}
}
}
if (argc == 5) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[2]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[3]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[4]);
}
if (_v) {
return _wrap_SBFrame_GetVariables__SWIG_0(L);
}
}
}
}
}
}
if (argc == 6) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[2]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[3]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[4]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[5]);
}
if (_v) {
return _wrap_SBFrame_GetVariables__SWIG_1(L);
}
}
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBFrame_GetVariables'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBFrame::GetVariables(bool,bool,bool,bool)\n"
" lldb::SBFrame::GetVariables(bool,bool,bool,bool,lldb::DynamicValueType)\n"
" lldb::SBFrame::GetVariables(lldb::SBVariablesOptions const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBFrame_GetRegisters(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::SBValueList result;
SWIG_check_num_args("lldb::SBFrame::GetRegisters",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetRegisters",1,"lldb::SBFrame *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetRegisters",1,SWIGTYPE_p_lldb__SBFrame);
}
result = (arg1)->GetRegisters();
{
lldb::SBValueList * resultptr = new lldb::SBValueList((const lldb::SBValueList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_FindVariable__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBFrame::FindVariable",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::FindVariable",1,"lldb::SBFrame *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::FindVariable",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_FindVariable",1,SWIGTYPE_p_lldb__SBFrame);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->FindVariable((char const *)arg2);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_FindVariable__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
char *arg2 = (char *) 0 ;
lldb::DynamicValueType arg3 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBFrame::FindVariable",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::FindVariable",1,"lldb::SBFrame *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::FindVariable",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFrame::FindVariable",3,"lldb::DynamicValueType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_FindVariable",1,SWIGTYPE_p_lldb__SBFrame);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (lldb::DynamicValueType)lua_tointeger(L, 3);
result = (arg1)->FindVariable((char const *)arg2,arg3);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_FindVariable(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBFrame_FindVariable__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBFrame_FindVariable__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBFrame_FindVariable'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBFrame::FindVariable(char const *)\n"
" lldb::SBFrame::FindVariable(char const *,lldb::DynamicValueType)\n");
lua_error(L);return 0;
}
static int _wrap_SBFrame_FindRegister(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBFrame::FindRegister",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::FindRegister",1,"lldb::SBFrame *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::FindRegister",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_FindRegister",1,SWIGTYPE_p_lldb__SBFrame);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->FindRegister((char const *)arg2);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetValueForVariablePath__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBFrame::GetValueForVariablePath",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetValueForVariablePath",1,"lldb::SBFrame *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::GetValueForVariablePath",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetValueForVariablePath",1,SWIGTYPE_p_lldb__SBFrame);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->GetValueForVariablePath((char const *)arg2);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetValueForVariablePath__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
char *arg2 = (char *) 0 ;
lldb::DynamicValueType arg3 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBFrame::GetValueForVariablePath",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetValueForVariablePath",1,"lldb::SBFrame *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::GetValueForVariablePath",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFrame::GetValueForVariablePath",3,"lldb::DynamicValueType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetValueForVariablePath",1,SWIGTYPE_p_lldb__SBFrame);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (lldb::DynamicValueType)lua_tointeger(L, 3);
result = (arg1)->GetValueForVariablePath((char const *)arg2,arg3);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_GetValueForVariablePath(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBFrame_GetValueForVariablePath__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBFrame_GetValueForVariablePath__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBFrame_GetValueForVariablePath'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBFrame::GetValueForVariablePath(char const *)\n"
" lldb::SBFrame::GetValueForVariablePath(char const *,lldb::DynamicValueType)\n");
lua_error(L);return 0;
}
static int _wrap_SBFrame_FindValue__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
char *arg2 = (char *) 0 ;
lldb::ValueType arg3 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBFrame::FindValue",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::FindValue",1,"lldb::SBFrame *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::FindValue",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFrame::FindValue",3,"lldb::ValueType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_FindValue",1,SWIGTYPE_p_lldb__SBFrame);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (lldb::ValueType)lua_tointeger(L, 3);
result = (arg1)->FindValue((char const *)arg2,arg3);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_FindValue__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
char *arg2 = (char *) 0 ;
lldb::ValueType arg3 ;
lldb::DynamicValueType arg4 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBFrame::FindValue",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::FindValue",1,"lldb::SBFrame *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::FindValue",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFrame::FindValue",3,"lldb::ValueType");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBFrame::FindValue",4,"lldb::DynamicValueType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_FindValue",1,SWIGTYPE_p_lldb__SBFrame);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (lldb::ValueType)lua_tointeger(L, 3);
arg4 = (lldb::DynamicValueType)lua_tointeger(L, 4);
result = (arg1)->FindValue((char const *)arg2,arg3,arg4);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame_FindValue(lua_State* L) {
int argc;
int argv[5]={
1,2,3,4,5
};
argc = lua_gettop(L);
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBFrame_FindValue__SWIG_0(L);
}
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[3]);
}
if (_v) {
return _wrap_SBFrame_FindValue__SWIG_1(L);
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBFrame_FindValue'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBFrame::FindValue(char const *,lldb::ValueType)\n"
" lldb::SBFrame::FindValue(char const *,lldb::ValueType,lldb::DynamicValueType)\n");
lua_error(L);return 0;
}
static int _wrap_SBFrame_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBFrame::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetDescription",1,"lldb::SBFrame *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFrame::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame_GetDescription",1,SWIGTYPE_p_lldb__SBFrame);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBFrame_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFrame___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBFrame::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::__str__",1,"lldb::SBFrame *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBFrame___tostring",1,SWIGTYPE_p_lldb__SBFrame);
}
result = lldb_SBFrame___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBFrame(void *obj) {
lldb::SBFrame *arg1 = (lldb::SBFrame *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBFrame(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBFrame);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBFrame_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBFrame_methods[]= {
{ "IsEqual", _wrap_SBFrame_IsEqual},
{ "IsValid", _wrap_SBFrame_IsValid},
{ "GetFrameID", _wrap_SBFrame_GetFrameID},
{ "GetCFA", _wrap_SBFrame_GetCFA},
{ "GetPC", _wrap_SBFrame_GetPC},
{ "SetPC", _wrap_SBFrame_SetPC},
{ "GetSP", _wrap_SBFrame_GetSP},
{ "GetFP", _wrap_SBFrame_GetFP},
{ "GetPCAddress", _wrap_SBFrame_GetPCAddress},
{ "GetSymbolContext", _wrap_SBFrame_GetSymbolContext},
{ "GetModule", _wrap_SBFrame_GetModule},
{ "GetCompileUnit", _wrap_SBFrame_GetCompileUnit},
{ "GetFunction", _wrap_SBFrame_GetFunction},
{ "GetSymbol", _wrap_SBFrame_GetSymbol},
{ "GetBlock", _wrap_SBFrame_GetBlock},
{ "GetDisplayFunctionName", _wrap_SBFrame_GetDisplayFunctionName},
{ "GetFunctionName", _wrap_SBFrame_GetFunctionName},
{ "GuessLanguage", _wrap_SBFrame_GuessLanguage},
{ "IsInlined", _wrap_SBFrame_IsInlined},
{ "IsArtificial", _wrap_SBFrame_IsArtificial},
{ "EvaluateExpression", _wrap_SBFrame_EvaluateExpression},
{ "GetFrameBlock", _wrap_SBFrame_GetFrameBlock},
{ "GetLineEntry", _wrap_SBFrame_GetLineEntry},
{ "GetThread", _wrap_SBFrame_GetThread},
{ "Disassemble", _wrap_SBFrame_Disassemble},
{ "Clear", _wrap_SBFrame_Clear},
{ "__eq", _wrap_SBFrame___eq},
{ "GetVariables", _wrap_SBFrame_GetVariables},
{ "GetRegisters", _wrap_SBFrame_GetRegisters},
{ "FindVariable", _wrap_SBFrame_FindVariable},
{ "FindRegister", _wrap_SBFrame_FindRegister},
{ "GetValueForVariablePath", _wrap_SBFrame_GetValueForVariablePath},
{ "FindValue", _wrap_SBFrame_FindValue},
{ "GetDescription", _wrap_SBFrame_GetDescription},
{ "__tostring", _wrap_SBFrame___tostring},
{0,0}
};
static swig_lua_method swig_SBFrame_meta[] = {
{ "__eq", _wrap_SBFrame___eq},
{ "__tostring", _wrap_SBFrame___tostring},
{0,0}
};
static swig_lua_attribute swig_SBFrame_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBFrame_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBFrame_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBFrame_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBFrame_Sf_SwigStatic = {
"SBFrame",
swig_SBFrame_Sf_SwigStatic_methods,
swig_SBFrame_Sf_SwigStatic_attributes,
swig_SBFrame_Sf_SwigStatic_constants,
swig_SBFrame_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBFrame_bases[] = {0};
static const char *swig_SBFrame_base_names[] = {0};
static swig_lua_class _wrap_class_SBFrame = { "SBFrame", "SBFrame", &SWIGTYPE_p_lldb__SBFrame,_proxy__wrap_new_SBFrame, swig_delete_SBFrame, swig_SBFrame_methods, swig_SBFrame_attributes, &swig_SBFrame_Sf_SwigStatic, swig_SBFrame_meta, swig_SBFrame_bases, swig_SBFrame_base_names };
static int _wrap_new_SBFunction__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *result = 0 ;
SWIG_check_num_args("lldb::SBFunction::SBFunction",0,0)
result = (lldb::SBFunction *)new lldb::SBFunction();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFunction,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBFunction__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *arg1 = 0 ;
lldb::SBFunction *result = 0 ;
SWIG_check_num_args("lldb::SBFunction::SBFunction",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBFunction::SBFunction",1,"lldb::SBFunction const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("new_SBFunction",1,SWIGTYPE_p_lldb__SBFunction);
}
result = (lldb::SBFunction *)new lldb::SBFunction((lldb::SBFunction const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFunction,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBFunction(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBFunction__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFunction, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBFunction__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBFunction'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBFunction::SBFunction()\n"
" lldb::SBFunction::SBFunction(lldb::SBFunction const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBFunction_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBFunction::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::IsValid",1,"lldb::SBFunction const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBFunction_IsValid",1,SWIGTYPE_p_lldb__SBFunction);
}
result = (bool)((lldb::SBFunction const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFunction_GetName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBFunction::GetName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetName",1,"lldb::SBFunction const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBFunction_GetName",1,SWIGTYPE_p_lldb__SBFunction);
}
result = (char *)((lldb::SBFunction const *)arg1)->GetName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFunction_GetDisplayName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBFunction::GetDisplayName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetDisplayName",1,"lldb::SBFunction const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBFunction_GetDisplayName",1,SWIGTYPE_p_lldb__SBFunction);
}
result = (char *)((lldb::SBFunction const *)arg1)->GetDisplayName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFunction_GetMangledName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBFunction::GetMangledName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetMangledName",1,"lldb::SBFunction const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBFunction_GetMangledName",1,SWIGTYPE_p_lldb__SBFunction);
}
result = (char *)((lldb::SBFunction const *)arg1)->GetMangledName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFunction_GetInstructions__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ;
lldb::SBTarget arg2 ;
lldb::SBTarget *argp2 ;
lldb::SBInstructionList result;
SWIG_check_num_args("lldb::SBFunction::GetInstructions",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetInstructions",1,"lldb::SBFunction *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFunction::GetInstructions",2,"lldb::SBTarget");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBFunction_GetInstructions",1,SWIGTYPE_p_lldb__SBFunction);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBFunction_GetInstructions",2,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = *argp2;
result = (arg1)->GetInstructions(arg2);
{
lldb::SBInstructionList * resultptr = new lldb::SBInstructionList((const lldb::SBInstructionList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFunction_GetInstructions__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ;
lldb::SBTarget arg2 ;
char *arg3 = (char *) 0 ;
lldb::SBTarget *argp2 ;
lldb::SBInstructionList result;
SWIG_check_num_args("lldb::SBFunction::GetInstructions",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetInstructions",1,"lldb::SBFunction *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFunction::GetInstructions",2,"lldb::SBTarget");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBFunction::GetInstructions",3,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBFunction_GetInstructions",1,SWIGTYPE_p_lldb__SBFunction);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBFunction_GetInstructions",2,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = *argp2;
arg3 = (char *)lua_tostring(L, 3);
result = (arg1)->GetInstructions(arg2,(char const *)arg3);
{
lldb::SBInstructionList * resultptr = new lldb::SBInstructionList((const lldb::SBInstructionList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFunction_GetInstructions(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFunction, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBFunction_GetInstructions__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFunction, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[2]);
}
if (_v) {
return _wrap_SBFunction_GetInstructions__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBFunction_GetInstructions'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBFunction::GetInstructions(lldb::SBTarget)\n"
" lldb::SBFunction::GetInstructions(lldb::SBTarget,char const *)\n");
lua_error(L);return 0;
}
static int _wrap_SBFunction_GetStartAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBFunction::GetStartAddress",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetStartAddress",1,"lldb::SBFunction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBFunction_GetStartAddress",1,SWIGTYPE_p_lldb__SBFunction);
}
result = (arg1)->GetStartAddress();
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFunction_GetEndAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBFunction::GetEndAddress",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetEndAddress",1,"lldb::SBFunction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBFunction_GetEndAddress",1,SWIGTYPE_p_lldb__SBFunction);
}
result = (arg1)->GetEndAddress();
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFunction_GetArgumentName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ;
uint32_t arg2 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBFunction::GetArgumentName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetArgumentName",1,"lldb::SBFunction *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBFunction::GetArgumentName",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBFunction_GetArgumentName",1,SWIGTYPE_p_lldb__SBFunction);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (char *)(arg1)->GetArgumentName(arg2);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFunction_GetPrologueByteSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBFunction::GetPrologueByteSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetPrologueByteSize",1,"lldb::SBFunction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBFunction_GetPrologueByteSize",1,SWIGTYPE_p_lldb__SBFunction);
}
result = (uint32_t)(arg1)->GetPrologueByteSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFunction_GetType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBFunction::GetType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetType",1,"lldb::SBFunction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBFunction_GetType",1,SWIGTYPE_p_lldb__SBFunction);
}
result = (arg1)->GetType();
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFunction_GetBlock(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ;
lldb::SBBlock result;
SWIG_check_num_args("lldb::SBFunction::GetBlock",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetBlock",1,"lldb::SBFunction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBFunction_GetBlock",1,SWIGTYPE_p_lldb__SBFunction);
}
result = (arg1)->GetBlock();
{
lldb::SBBlock * resultptr = new lldb::SBBlock((const lldb::SBBlock &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFunction_GetLanguage(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ;
lldb::LanguageType result;
SWIG_check_num_args("lldb::SBFunction::GetLanguage",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetLanguage",1,"lldb::SBFunction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBFunction_GetLanguage",1,SWIGTYPE_p_lldb__SBFunction);
}
result = (lldb::LanguageType)(arg1)->GetLanguage();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFunction_GetIsOptimized(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBFunction::GetIsOptimized",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetIsOptimized",1,"lldb::SBFunction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBFunction_GetIsOptimized",1,SWIGTYPE_p_lldb__SBFunction);
}
result = (bool)(arg1)->GetIsOptimized();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFunction_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBFunction::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetDescription",1,"lldb::SBFunction *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFunction::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBFunction_GetDescription",1,SWIGTYPE_p_lldb__SBFunction);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBFunction_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFunction___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ;
lldb::SBFunction *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBFunction::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::operator ==",1,"lldb::SBFunction const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFunction::operator ==",2,"lldb::SBFunction const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBFunction___eq",1,SWIGTYPE_p_lldb__SBFunction);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBFunction___eq",2,SWIGTYPE_p_lldb__SBFunction);
}
result = (bool)((lldb::SBFunction const *)arg1)->operator ==((lldb::SBFunction const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBFunction___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBFunction::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::__str__",1,"lldb::SBFunction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBFunction___tostring",1,SWIGTYPE_p_lldb__SBFunction);
}
result = lldb_SBFunction___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBFunction(void *obj) {
lldb::SBFunction *arg1 = (lldb::SBFunction *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBFunction(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBFunction);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBFunction_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBFunction_methods[]= {
{ "IsValid", _wrap_SBFunction_IsValid},
{ "GetName", _wrap_SBFunction_GetName},
{ "GetDisplayName", _wrap_SBFunction_GetDisplayName},
{ "GetMangledName", _wrap_SBFunction_GetMangledName},
{ "GetInstructions", _wrap_SBFunction_GetInstructions},
{ "GetStartAddress", _wrap_SBFunction_GetStartAddress},
{ "GetEndAddress", _wrap_SBFunction_GetEndAddress},
{ "GetArgumentName", _wrap_SBFunction_GetArgumentName},
{ "GetPrologueByteSize", _wrap_SBFunction_GetPrologueByteSize},
{ "GetType", _wrap_SBFunction_GetType},
{ "GetBlock", _wrap_SBFunction_GetBlock},
{ "GetLanguage", _wrap_SBFunction_GetLanguage},
{ "GetIsOptimized", _wrap_SBFunction_GetIsOptimized},
{ "GetDescription", _wrap_SBFunction_GetDescription},
{ "__eq", _wrap_SBFunction___eq},
{ "__tostring", _wrap_SBFunction___tostring},
{0,0}
};
static swig_lua_method swig_SBFunction_meta[] = {
{ "__eq", _wrap_SBFunction___eq},
{ "__tostring", _wrap_SBFunction___tostring},
{0,0}
};
static swig_lua_attribute swig_SBFunction_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBFunction_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBFunction_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBFunction_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBFunction_Sf_SwigStatic = {
"SBFunction",
swig_SBFunction_Sf_SwigStatic_methods,
swig_SBFunction_Sf_SwigStatic_attributes,
swig_SBFunction_Sf_SwigStatic_constants,
swig_SBFunction_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBFunction_bases[] = {0};
static const char *swig_SBFunction_base_names[] = {0};
static swig_lua_class _wrap_class_SBFunction = { "SBFunction", "SBFunction", &SWIGTYPE_p_lldb__SBFunction,_proxy__wrap_new_SBFunction, swig_delete_SBFunction, swig_SBFunction_methods, swig_SBFunction_attributes, &swig_SBFunction_Sf_SwigStatic, swig_SBFunction_meta, swig_SBFunction_bases, swig_SBFunction_base_names };
static int _wrap_SBHostOS_GetProgramFileSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBHostOS::GetProgramFileSpec",0,0)
result = lldb::SBHostOS::GetProgramFileSpec();
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBHostOS_GetLLDBPythonPath(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBHostOS::GetLLDBPythonPath",0,0)
result = lldb::SBHostOS::GetLLDBPythonPath();
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBHostOS_GetLLDBPath(lua_State* L) {
int SWIG_arg = 0;
lldb::PathType arg1 ;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBHostOS::GetLLDBPath",1,1)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBHostOS::GetLLDBPath",1,"lldb::PathType");
arg1 = (lldb::PathType)lua_tointeger(L, 1);
result = lldb::SBHostOS::GetLLDBPath(arg1);
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBHostOS_GetUserHomeDirectory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBHostOS::GetUserHomeDirectory",0,0)
result = lldb::SBHostOS::GetUserHomeDirectory();
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBHostOS_ThreadCreated(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
SWIG_check_num_args("lldb::SBHostOS::ThreadCreated",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBHostOS::ThreadCreated",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
lldb::SBHostOS::ThreadCreated((char const *)arg1);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBHostOS_ThreadCreate(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
lldb::thread_func_t arg2 = (lldb::thread_func_t) 0 ;
void *arg3 = (void *) 0 ;
lldb::SBError *arg4 = (lldb::SBError *) 0 ;
lldb::thread_t result;
SWIG_check_num_args("lldb::SBHostOS::ThreadCreate",4,4)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBHostOS::ThreadCreate",1,"char const *");
if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBHostOS::ThreadCreate",2,"lldb::thread_func_t");
if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("lldb::SBHostOS::ThreadCreate",3,"void *");
if(!SWIG_isptrtype(L,4)) SWIG_fail_arg("lldb::SBHostOS::ThreadCreate",4,"lldb::SBError *");
arg1 = (char *)lua_tostring(L, 1);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_f_p_void__p_void,0))){
SWIG_fail_ptr("SBHostOS_ThreadCreate",2,SWIGTYPE_p_f_p_void__p_void);
}
arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"SBHostOS_ThreadCreate");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBHostOS_ThreadCreate",4,SWIGTYPE_p_lldb__SBError);
}
result = lldb::SBHostOS::ThreadCreate((char const *)arg1,arg2,arg3,arg4);
{
lldb::thread_t * resultptr = new lldb::thread_t((const lldb::thread_t &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_pthread_t,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBHostOS_ThreadCancel(lua_State* L) {
int SWIG_arg = 0;
lldb::thread_t arg1 ;
lldb::SBError *arg2 = (lldb::SBError *) 0 ;
lldb::thread_t *argp1 ;
bool result;
SWIG_check_num_args("lldb::SBHostOS::ThreadCancel",2,2)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBHostOS::ThreadCancel",1,"lldb::thread_t");
if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBHostOS::ThreadCancel",2,"lldb::SBError *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_pthread_t,0))){
SWIG_fail_ptr("SBHostOS_ThreadCancel",1,SWIGTYPE_p_pthread_t);
}
arg1 = *argp1;
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBHostOS_ThreadCancel",2,SWIGTYPE_p_lldb__SBError);
}
result = (bool)lldb::SBHostOS::ThreadCancel(arg1,arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBHostOS_ThreadDetach(lua_State* L) {
int SWIG_arg = 0;
lldb::thread_t arg1 ;
lldb::SBError *arg2 = (lldb::SBError *) 0 ;
lldb::thread_t *argp1 ;
bool result;
SWIG_check_num_args("lldb::SBHostOS::ThreadDetach",2,2)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBHostOS::ThreadDetach",1,"lldb::thread_t");
if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBHostOS::ThreadDetach",2,"lldb::SBError *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_pthread_t,0))){
SWIG_fail_ptr("SBHostOS_ThreadDetach",1,SWIGTYPE_p_pthread_t);
}
arg1 = *argp1;
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBHostOS_ThreadDetach",2,SWIGTYPE_p_lldb__SBError);
}
result = (bool)lldb::SBHostOS::ThreadDetach(arg1,arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBHostOS_ThreadJoin(lua_State* L) {
int SWIG_arg = 0;
lldb::thread_t arg1 ;
lldb::thread_result_t *arg2 = (lldb::thread_result_t *) 0 ;
lldb::SBError *arg3 = (lldb::SBError *) 0 ;
lldb::thread_t *argp1 ;
bool result;
SWIG_check_num_args("lldb::SBHostOS::ThreadJoin",3,3)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBHostOS::ThreadJoin",1,"lldb::thread_t");
if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBHostOS::ThreadJoin",2,"lldb::thread_result_t *");
if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("lldb::SBHostOS::ThreadJoin",3,"lldb::SBError *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_pthread_t,0))){
SWIG_fail_ptr("SBHostOS_ThreadJoin",1,SWIGTYPE_p_pthread_t);
}
arg1 = *argp1;
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_p_void,0))){
SWIG_fail_ptr("SBHostOS_ThreadJoin",2,SWIGTYPE_p_p_void);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBHostOS_ThreadJoin",3,SWIGTYPE_p_lldb__SBError);
}
result = (bool)lldb::SBHostOS::ThreadJoin(arg1,arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBHostOS(lua_State* L) {
int SWIG_arg = 0;
lldb::SBHostOS *result = 0 ;
SWIG_check_num_args("lldb::SBHostOS::SBHostOS",0,0)
result = (lldb::SBHostOS *)new lldb::SBHostOS();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBHostOS,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBHostOS(void *obj) {
lldb::SBHostOS *arg1 = (lldb::SBHostOS *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBHostOS(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBHostOS);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBHostOS_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBHostOS_methods[]= {
{0,0}
};
static swig_lua_method swig_SBHostOS_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBHostOS_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBHostOS_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBHostOS_Sf_SwigStatic_methods[]= {
{ "GetProgramFileSpec", _wrap_SBHostOS_GetProgramFileSpec},
{ "GetLLDBPythonPath", _wrap_SBHostOS_GetLLDBPythonPath},
{ "GetLLDBPath", _wrap_SBHostOS_GetLLDBPath},
{ "GetUserHomeDirectory", _wrap_SBHostOS_GetUserHomeDirectory},
{ "ThreadCreated", _wrap_SBHostOS_ThreadCreated},
{ "ThreadCreate", _wrap_SBHostOS_ThreadCreate},
{ "ThreadCancel", _wrap_SBHostOS_ThreadCancel},
{ "ThreadDetach", _wrap_SBHostOS_ThreadDetach},
{ "ThreadJoin", _wrap_SBHostOS_ThreadJoin},
{0,0}
};
static swig_lua_class* swig_SBHostOS_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBHostOS_Sf_SwigStatic = {
"SBHostOS",
swig_SBHostOS_Sf_SwigStatic_methods,
swig_SBHostOS_Sf_SwigStatic_attributes,
swig_SBHostOS_Sf_SwigStatic_constants,
swig_SBHostOS_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBHostOS_bases[] = {0};
static const char *swig_SBHostOS_base_names[] = {0};
static swig_lua_class _wrap_class_SBHostOS = { "SBHostOS", "SBHostOS", &SWIGTYPE_p_lldb__SBHostOS,_proxy__wrap_new_SBHostOS, swig_delete_SBHostOS, swig_SBHostOS_methods, swig_SBHostOS_attributes, &swig_SBHostOS_Sf_SwigStatic, swig_SBHostOS_meta, swig_SBHostOS_bases, swig_SBHostOS_base_names };
static int _wrap_new_SBInstruction__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *result = 0 ;
SWIG_check_num_args("lldb::SBInstruction::SBInstruction",0,0)
result = (lldb::SBInstruction *)new lldb::SBInstruction();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBInstruction,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBInstruction__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *arg1 = 0 ;
lldb::SBInstruction *result = 0 ;
SWIG_check_num_args("lldb::SBInstruction::SBInstruction",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBInstruction::SBInstruction",1,"lldb::SBInstruction const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("new_SBInstruction",1,SWIGTYPE_p_lldb__SBInstruction);
}
result = (lldb::SBInstruction *)new lldb::SBInstruction((lldb::SBInstruction const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBInstruction,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBInstruction(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBInstruction__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBInstruction, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBInstruction__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBInstruction'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBInstruction::SBInstruction()\n"
" lldb::SBInstruction::SBInstruction(lldb::SBInstruction const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBInstruction_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBInstruction::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::IsValid",1,"lldb::SBInstruction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("SBInstruction_IsValid",1,SWIGTYPE_p_lldb__SBInstruction);
}
result = (bool)(arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstruction_GetAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBInstruction::GetAddress",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::GetAddress",1,"lldb::SBInstruction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("SBInstruction_GetAddress",1,SWIGTYPE_p_lldb__SBInstruction);
}
result = (arg1)->GetAddress();
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstruction_GetMnemonic(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ;
lldb::SBTarget arg2 ;
lldb::SBTarget *argp2 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBInstruction::GetMnemonic",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::GetMnemonic",1,"lldb::SBInstruction *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstruction::GetMnemonic",2,"lldb::SBTarget");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("SBInstruction_GetMnemonic",1,SWIGTYPE_p_lldb__SBInstruction);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBInstruction_GetMnemonic",2,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = *argp2;
result = (char *)(arg1)->GetMnemonic(arg2);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstruction_GetOperands(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ;
lldb::SBTarget arg2 ;
lldb::SBTarget *argp2 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBInstruction::GetOperands",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::GetOperands",1,"lldb::SBInstruction *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstruction::GetOperands",2,"lldb::SBTarget");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("SBInstruction_GetOperands",1,SWIGTYPE_p_lldb__SBInstruction);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBInstruction_GetOperands",2,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = *argp2;
result = (char *)(arg1)->GetOperands(arg2);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstruction_GetComment(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ;
lldb::SBTarget arg2 ;
lldb::SBTarget *argp2 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBInstruction::GetComment",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::GetComment",1,"lldb::SBInstruction *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstruction::GetComment",2,"lldb::SBTarget");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("SBInstruction_GetComment",1,SWIGTYPE_p_lldb__SBInstruction);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBInstruction_GetComment",2,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = *argp2;
result = (char *)(arg1)->GetComment(arg2);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstruction_GetData(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ;
lldb::SBTarget arg2 ;
lldb::SBTarget *argp2 ;
lldb::SBData result;
SWIG_check_num_args("lldb::SBInstruction::GetData",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::GetData",1,"lldb::SBInstruction *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstruction::GetData",2,"lldb::SBTarget");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("SBInstruction_GetData",1,SWIGTYPE_p_lldb__SBInstruction);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBInstruction_GetData",2,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = *argp2;
result = (arg1)->GetData(arg2);
{
lldb::SBData * resultptr = new lldb::SBData((const lldb::SBData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstruction_GetByteSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBInstruction::GetByteSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::GetByteSize",1,"lldb::SBInstruction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("SBInstruction_GetByteSize",1,SWIGTYPE_p_lldb__SBInstruction);
}
result = (arg1)->GetByteSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstruction_DoesBranch(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBInstruction::DoesBranch",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::DoesBranch",1,"lldb::SBInstruction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("SBInstruction_DoesBranch",1,SWIGTYPE_p_lldb__SBInstruction);
}
result = (bool)(arg1)->DoesBranch();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstruction_HasDelaySlot(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBInstruction::HasDelaySlot",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::HasDelaySlot",1,"lldb::SBInstruction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("SBInstruction_HasDelaySlot",1,SWIGTYPE_p_lldb__SBInstruction);
}
result = (bool)(arg1)->HasDelaySlot();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstruction_CanSetBreakpoint(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBInstruction::CanSetBreakpoint",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::CanSetBreakpoint",1,"lldb::SBInstruction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("SBInstruction_CanSetBreakpoint",1,SWIGTYPE_p_lldb__SBInstruction);
}
result = (bool)(arg1)->CanSetBreakpoint();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstruction_Print__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ;
lldb::SBFile arg2 ;
lldb::SBFile *argp2 ;
SWIG_check_num_args("lldb::SBInstruction::Print",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::Print",1,"lldb::SBInstruction *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstruction::Print",2,"lldb::SBFile");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("SBInstruction_Print",1,SWIGTYPE_p_lldb__SBInstruction);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBInstruction_Print",2,SWIGTYPE_p_lldb__SBFile);
}
arg2 = *argp2;
(arg1)->Print(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstruction_Print__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
SWIG_check_num_args("lldb::SBInstruction::Print",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::Print",1,"lldb::SBInstruction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("SBInstruction_Print",1,SWIGTYPE_p_lldb__SBInstruction);
}
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg2 = file_sp;
}
(arg1)->Print(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstruction_Print(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBInstruction, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBInstruction_Print__SWIG_0(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBInstruction, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_isuserdata(L, argv[1])) &&
(luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr);
}
if (_v) {
return _wrap_SBInstruction_Print__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBInstruction_Print'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBInstruction::Print(lldb::SBFile)\n"
" lldb::SBInstruction::Print(lldb::FileSP)\n");
lua_error(L);return 0;
}
static int _wrap_SBInstruction_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBInstruction::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::GetDescription",1,"lldb::SBInstruction *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstruction::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("SBInstruction_GetDescription",1,SWIGTYPE_p_lldb__SBInstruction);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBInstruction_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstruction_EmulateWithFrame(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ;
lldb::SBFrame *arg2 = 0 ;
uint32_t arg3 ;
bool result;
SWIG_check_num_args("lldb::SBInstruction::EmulateWithFrame",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::EmulateWithFrame",1,"lldb::SBInstruction *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstruction::EmulateWithFrame",2,"lldb::SBFrame &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBInstruction::EmulateWithFrame",3,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("SBInstruction_EmulateWithFrame",1,SWIGTYPE_p_lldb__SBInstruction);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBInstruction_EmulateWithFrame",2,SWIGTYPE_p_lldb__SBFrame);
}
arg3 = (uint32_t)lua_tointeger(L, 3);
result = (bool)(arg1)->EmulateWithFrame(*arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstruction_DumpEmulation(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ;
char *arg2 = (char *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBInstruction::DumpEmulation",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::DumpEmulation",1,"lldb::SBInstruction *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBInstruction::DumpEmulation",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("SBInstruction_DumpEmulation",1,SWIGTYPE_p_lldb__SBInstruction);
}
arg2 = (char *)lua_tostring(L, 2);
result = (bool)(arg1)->DumpEmulation((char const *)arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstruction_TestEmulation(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ;
lldb::SBStream *arg2 = 0 ;
char *arg3 = (char *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBInstruction::TestEmulation",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::TestEmulation",1,"lldb::SBInstruction *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstruction::TestEmulation",2,"lldb::SBStream &");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBInstruction::TestEmulation",3,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("SBInstruction_TestEmulation",1,SWIGTYPE_p_lldb__SBInstruction);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBInstruction_TestEmulation",2,SWIGTYPE_p_lldb__SBStream);
}
arg3 = (char *)lua_tostring(L, 3);
result = (bool)(arg1)->TestEmulation(*arg2,(char const *)arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstruction___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBInstruction::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::__str__",1,"lldb::SBInstruction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("SBInstruction___tostring",1,SWIGTYPE_p_lldb__SBInstruction);
}
result = lldb_SBInstruction___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBInstruction(void *obj) {
lldb::SBInstruction *arg1 = (lldb::SBInstruction *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBInstruction(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBInstruction);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBInstruction_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBInstruction_methods[]= {
{ "IsValid", _wrap_SBInstruction_IsValid},
{ "GetAddress", _wrap_SBInstruction_GetAddress},
{ "GetMnemonic", _wrap_SBInstruction_GetMnemonic},
{ "GetOperands", _wrap_SBInstruction_GetOperands},
{ "GetComment", _wrap_SBInstruction_GetComment},
{ "GetData", _wrap_SBInstruction_GetData},
{ "GetByteSize", _wrap_SBInstruction_GetByteSize},
{ "DoesBranch", _wrap_SBInstruction_DoesBranch},
{ "HasDelaySlot", _wrap_SBInstruction_HasDelaySlot},
{ "CanSetBreakpoint", _wrap_SBInstruction_CanSetBreakpoint},
{ "Print", _wrap_SBInstruction_Print},
{ "GetDescription", _wrap_SBInstruction_GetDescription},
{ "EmulateWithFrame", _wrap_SBInstruction_EmulateWithFrame},
{ "DumpEmulation", _wrap_SBInstruction_DumpEmulation},
{ "TestEmulation", _wrap_SBInstruction_TestEmulation},
{ "__tostring", _wrap_SBInstruction___tostring},
{0,0}
};
static swig_lua_method swig_SBInstruction_meta[] = {
{ "__tostring", _wrap_SBInstruction___tostring},
{0,0}
};
static swig_lua_attribute swig_SBInstruction_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBInstruction_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBInstruction_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBInstruction_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBInstruction_Sf_SwigStatic = {
"SBInstruction",
swig_SBInstruction_Sf_SwigStatic_methods,
swig_SBInstruction_Sf_SwigStatic_attributes,
swig_SBInstruction_Sf_SwigStatic_constants,
swig_SBInstruction_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBInstruction_bases[] = {0};
static const char *swig_SBInstruction_base_names[] = {0};
static swig_lua_class _wrap_class_SBInstruction = { "SBInstruction", "SBInstruction", &SWIGTYPE_p_lldb__SBInstruction,_proxy__wrap_new_SBInstruction, swig_delete_SBInstruction, swig_SBInstruction_methods, swig_SBInstruction_attributes, &swig_SBInstruction_Sf_SwigStatic, swig_SBInstruction_meta, swig_SBInstruction_bases, swig_SBInstruction_base_names };
static int _wrap_new_SBInstructionList__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstructionList *result = 0 ;
SWIG_check_num_args("lldb::SBInstructionList::SBInstructionList",0,0)
result = (lldb::SBInstructionList *)new lldb::SBInstructionList();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBInstructionList__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstructionList *arg1 = 0 ;
lldb::SBInstructionList *result = 0 ;
SWIG_check_num_args("lldb::SBInstructionList::SBInstructionList",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBInstructionList::SBInstructionList",1,"lldb::SBInstructionList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){
SWIG_fail_ptr("new_SBInstructionList",1,SWIGTYPE_p_lldb__SBInstructionList);
}
result = (lldb::SBInstructionList *)new lldb::SBInstructionList((lldb::SBInstructionList const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBInstructionList(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBInstructionList__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBInstructionList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBInstructionList__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBInstructionList'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBInstructionList::SBInstructionList()\n"
" lldb::SBInstructionList::SBInstructionList(lldb::SBInstructionList const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBInstructionList_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBInstructionList::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::IsValid",1,"lldb::SBInstructionList const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){
SWIG_fail_ptr("SBInstructionList_IsValid",1,SWIGTYPE_p_lldb__SBInstructionList);
}
result = (bool)((lldb::SBInstructionList const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstructionList_GetSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBInstructionList::GetSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::GetSize",1,"lldb::SBInstructionList *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){
SWIG_fail_ptr("SBInstructionList_GetSize",1,SWIGTYPE_p_lldb__SBInstructionList);
}
result = (arg1)->GetSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstructionList_GetInstructionAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ;
uint32_t arg2 ;
lldb::SBInstruction result;
SWIG_check_num_args("lldb::SBInstructionList::GetInstructionAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::GetInstructionAtIndex",1,"lldb::SBInstructionList *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBInstructionList::GetInstructionAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){
SWIG_fail_ptr("SBInstructionList_GetInstructionAtIndex",1,SWIGTYPE_p_lldb__SBInstructionList);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetInstructionAtIndex(arg2);
{
lldb::SBInstruction * resultptr = new lldb::SBInstruction((const lldb::SBInstruction &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstruction,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstructionList_GetInstructionsCount(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ;
lldb::SBAddress *arg2 = 0 ;
lldb::SBAddress *arg3 = 0 ;
bool arg4 ;
size_t result;
SWIG_check_num_args("lldb::SBInstructionList::GetInstructionsCount",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::GetInstructionsCount",1,"lldb::SBInstructionList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstructionList::GetInstructionsCount",2,"lldb::SBAddress const &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBInstructionList::GetInstructionsCount",3,"lldb::SBAddress const &");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBInstructionList::GetInstructionsCount",4,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){
SWIG_fail_ptr("SBInstructionList_GetInstructionsCount",1,SWIGTYPE_p_lldb__SBInstructionList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBInstructionList_GetInstructionsCount",2,SWIGTYPE_p_lldb__SBAddress);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBInstructionList_GetInstructionsCount",3,SWIGTYPE_p_lldb__SBAddress);
}
arg4 = (lua_toboolean(L, 4)!=0);
result = (arg1)->GetInstructionsCount((lldb::SBAddress const &)*arg2,(lldb::SBAddress const &)*arg3,arg4);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstructionList_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ;
SWIG_check_num_args("lldb::SBInstructionList::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::Clear",1,"lldb::SBInstructionList *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){
SWIG_fail_ptr("SBInstructionList_Clear",1,SWIGTYPE_p_lldb__SBInstructionList);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstructionList_AppendInstruction(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ;
lldb::SBInstruction arg2 ;
lldb::SBInstruction *argp2 ;
SWIG_check_num_args("lldb::SBInstructionList::AppendInstruction",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::AppendInstruction",1,"lldb::SBInstructionList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstructionList::AppendInstruction",2,"lldb::SBInstruction");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){
SWIG_fail_ptr("SBInstructionList_AppendInstruction",1,SWIGTYPE_p_lldb__SBInstructionList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBInstruction,0))){
SWIG_fail_ptr("SBInstructionList_AppendInstruction",2,SWIGTYPE_p_lldb__SBInstruction);
}
arg2 = *argp2;
(arg1)->AppendInstruction(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstructionList_Print__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ;
lldb::SBFile arg2 ;
lldb::SBFile *argp2 ;
SWIG_check_num_args("lldb::SBInstructionList::Print",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::Print",1,"lldb::SBInstructionList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstructionList::Print",2,"lldb::SBFile");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){
SWIG_fail_ptr("SBInstructionList_Print",1,SWIGTYPE_p_lldb__SBInstructionList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBInstructionList_Print",2,SWIGTYPE_p_lldb__SBFile);
}
arg2 = *argp2;
(arg1)->Print(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstructionList_Print__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
SWIG_check_num_args("lldb::SBInstructionList::Print",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::Print",1,"lldb::SBInstructionList *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){
SWIG_fail_ptr("SBInstructionList_Print",1,SWIGTYPE_p_lldb__SBInstructionList);
}
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg2 = file_sp;
}
(arg1)->Print(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstructionList_Print(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBInstructionList, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBInstructionList_Print__SWIG_0(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBInstructionList, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_isuserdata(L, argv[1])) &&
(luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr);
}
if (_v) {
return _wrap_SBInstructionList_Print__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBInstructionList_Print'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBInstructionList::Print(lldb::SBFile)\n"
" lldb::SBInstructionList::Print(lldb::FileSP)\n");
lua_error(L);return 0;
}
static int _wrap_SBInstructionList_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBInstructionList::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::GetDescription",1,"lldb::SBInstructionList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstructionList::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){
SWIG_fail_ptr("SBInstructionList_GetDescription",1,SWIGTYPE_p_lldb__SBInstructionList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBInstructionList_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstructionList_DumpEmulationForAllInstructions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ;
char *arg2 = (char *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBInstructionList::DumpEmulationForAllInstructions",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::DumpEmulationForAllInstructions",1,"lldb::SBInstructionList *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBInstructionList::DumpEmulationForAllInstructions",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){
SWIG_fail_ptr("SBInstructionList_DumpEmulationForAllInstructions",1,SWIGTYPE_p_lldb__SBInstructionList);
}
arg2 = (char *)lua_tostring(L, 2);
result = (bool)(arg1)->DumpEmulationForAllInstructions((char const *)arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBInstructionList___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBInstructionList::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::__str__",1,"lldb::SBInstructionList *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){
SWIG_fail_ptr("SBInstructionList___tostring",1,SWIGTYPE_p_lldb__SBInstructionList);
}
result = lldb_SBInstructionList___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBInstructionList(void *obj) {
lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBInstructionList(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBInstructionList);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBInstructionList_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBInstructionList_methods[]= {
{ "IsValid", _wrap_SBInstructionList_IsValid},
{ "GetSize", _wrap_SBInstructionList_GetSize},
{ "GetInstructionAtIndex", _wrap_SBInstructionList_GetInstructionAtIndex},
{ "GetInstructionsCount", _wrap_SBInstructionList_GetInstructionsCount},
{ "Clear", _wrap_SBInstructionList_Clear},
{ "AppendInstruction", _wrap_SBInstructionList_AppendInstruction},
{ "Print", _wrap_SBInstructionList_Print},
{ "GetDescription", _wrap_SBInstructionList_GetDescription},
{ "DumpEmulationForAllInstructions", _wrap_SBInstructionList_DumpEmulationForAllInstructions},
{ "__tostring", _wrap_SBInstructionList___tostring},
{0,0}
};
static swig_lua_method swig_SBInstructionList_meta[] = {
{ "__tostring", _wrap_SBInstructionList___tostring},
{0,0}
};
static swig_lua_attribute swig_SBInstructionList_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBInstructionList_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBInstructionList_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBInstructionList_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBInstructionList_Sf_SwigStatic = {
"SBInstructionList",
swig_SBInstructionList_Sf_SwigStatic_methods,
swig_SBInstructionList_Sf_SwigStatic_attributes,
swig_SBInstructionList_Sf_SwigStatic_constants,
swig_SBInstructionList_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBInstructionList_bases[] = {0};
static const char *swig_SBInstructionList_base_names[] = {0};
static swig_lua_class _wrap_class_SBInstructionList = { "SBInstructionList", "SBInstructionList", &SWIGTYPE_p_lldb__SBInstructionList,_proxy__wrap_new_SBInstructionList, swig_delete_SBInstructionList, swig_SBInstructionList_methods, swig_SBInstructionList_attributes, &swig_SBInstructionList_Sf_SwigStatic, swig_SBInstructionList_meta, swig_SBInstructionList_bases, swig_SBInstructionList_base_names };
static int _wrap_SBLanguageRuntime_GetLanguageTypeFromString(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
lldb::LanguageType result;
SWIG_check_num_args("lldb::SBLanguageRuntime::GetLanguageTypeFromString",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBLanguageRuntime::GetLanguageTypeFromString",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = (lldb::LanguageType)lldb::SBLanguageRuntime::GetLanguageTypeFromString((char const *)arg1);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLanguageRuntime_GetNameForLanguageType(lua_State* L) {
int SWIG_arg = 0;
lldb::LanguageType arg1 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBLanguageRuntime::GetNameForLanguageType",1,1)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBLanguageRuntime::GetNameForLanguageType",1,"lldb::LanguageType");
arg1 = (lldb::LanguageType)lua_tointeger(L, 1);
result = (char *)lldb::SBLanguageRuntime::GetNameForLanguageType(arg1);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBLanguageRuntime(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLanguageRuntime *result = 0 ;
SWIG_check_num_args("lldb::SBLanguageRuntime::SBLanguageRuntime",0,0)
result = (lldb::SBLanguageRuntime *)new lldb::SBLanguageRuntime();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBLanguageRuntime,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBLanguageRuntime(void *obj) {
lldb::SBLanguageRuntime *arg1 = (lldb::SBLanguageRuntime *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBLanguageRuntime(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBLanguageRuntime);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBLanguageRuntime_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBLanguageRuntime_methods[]= {
{0,0}
};
static swig_lua_method swig_SBLanguageRuntime_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBLanguageRuntime_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBLanguageRuntime_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBLanguageRuntime_Sf_SwigStatic_methods[]= {
{ "GetLanguageTypeFromString", _wrap_SBLanguageRuntime_GetLanguageTypeFromString},
{ "GetNameForLanguageType", _wrap_SBLanguageRuntime_GetNameForLanguageType},
{0,0}
};
static swig_lua_class* swig_SBLanguageRuntime_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBLanguageRuntime_Sf_SwigStatic = {
"SBLanguageRuntime",
swig_SBLanguageRuntime_Sf_SwigStatic_methods,
swig_SBLanguageRuntime_Sf_SwigStatic_attributes,
swig_SBLanguageRuntime_Sf_SwigStatic_constants,
swig_SBLanguageRuntime_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBLanguageRuntime_bases[] = {0};
static const char *swig_SBLanguageRuntime_base_names[] = {0};
static swig_lua_class _wrap_class_SBLanguageRuntime = { "SBLanguageRuntime", "SBLanguageRuntime", &SWIGTYPE_p_lldb__SBLanguageRuntime,_proxy__wrap_new_SBLanguageRuntime, swig_delete_SBLanguageRuntime, swig_SBLanguageRuntime_methods, swig_SBLanguageRuntime_attributes, &swig_SBLanguageRuntime_Sf_SwigStatic, swig_SBLanguageRuntime_meta, swig_SBLanguageRuntime_bases, swig_SBLanguageRuntime_base_names };
static int _wrap_new_SBLaunchInfo(lua_State* L) {
int SWIG_arg = 0;
char **arg1 = (char **) 0 ;
lldb::SBLaunchInfo *result = 0 ;
SWIG_check_num_args("lldb::SBLaunchInfo::SBLaunchInfo",1,1)
{
if (lua_istable(L, 1)) {
size_t size = lua_rawlen(L, 1);
arg1 = (char **)malloc((size + 1) * sizeof(char *));
int i = 0, j = 0;
while (i++ < size) {
lua_rawgeti(L, 1, i);
if (!lua_isstring(L, -1)) {
// if current element cannot be converted to string, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain strings");
}
arg1[j++] = (char *)lua_tostring(L, -1);
lua_pop(L, 1);
}
arg1[j] = 0;
} else if (lua_isnil(L, 1)) {
// "nil" is also acceptable, equivalent as an empty table
arg1 = NULL;
} else {
return luaL_error(L, "A list of strings expected");
}
}
result = (lldb::SBLaunchInfo *)new lldb::SBLaunchInfo((char const **)arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBLaunchInfo,1); SWIG_arg++;
{
free((char *) arg1);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free((char *) arg1);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetProcessID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
lldb::pid_t result;
SWIG_check_num_args("lldb::SBLaunchInfo::GetProcessID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetProcessID",1,"lldb::SBLaunchInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetProcessID",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (lldb::pid_t)(arg1)->GetProcessID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetUserID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBLaunchInfo::GetUserID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetUserID",1,"lldb::SBLaunchInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetUserID",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (uint32_t)(arg1)->GetUserID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetGroupID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBLaunchInfo::GetGroupID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetGroupID",1,"lldb::SBLaunchInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetGroupID",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (uint32_t)(arg1)->GetGroupID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_UserIDIsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBLaunchInfo::UserIDIsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::UserIDIsValid",1,"lldb::SBLaunchInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_UserIDIsValid",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (bool)(arg1)->UserIDIsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GroupIDIsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBLaunchInfo::GroupIDIsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GroupIDIsValid",1,"lldb::SBLaunchInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GroupIDIsValid",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (bool)(arg1)->GroupIDIsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_SetUserID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBLaunchInfo::SetUserID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetUserID",1,"lldb::SBLaunchInfo *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetUserID",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_SetUserID",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetUserID(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_SetGroupID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBLaunchInfo::SetGroupID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetGroupID",1,"lldb::SBLaunchInfo *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetGroupID",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_SetGroupID",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetGroupID(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetExecutableFile(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBLaunchInfo::GetExecutableFile",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetExecutableFile",1,"lldb::SBLaunchInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetExecutableFile",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (arg1)->GetExecutableFile();
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_SetExecutableFile(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
lldb::SBFileSpec arg2 ;
bool arg3 ;
lldb::SBFileSpec *argp2 ;
SWIG_check_num_args("lldb::SBLaunchInfo::SetExecutableFile",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetExecutableFile",1,"lldb::SBLaunchInfo *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetExecutableFile",2,"lldb::SBFileSpec");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBLaunchInfo::SetExecutableFile",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_SetExecutableFile",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBLaunchInfo_SetExecutableFile",2,SWIGTYPE_p_lldb__SBFileSpec);
}
arg2 = *argp2;
arg3 = (lua_toboolean(L, 3)!=0);
(arg1)->SetExecutableFile(arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetListener(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
lldb::SBListener result;
SWIG_check_num_args("lldb::SBLaunchInfo::GetListener",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetListener",1,"lldb::SBLaunchInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetListener",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (arg1)->GetListener();
{
lldb::SBListener * resultptr = new lldb::SBListener((const lldb::SBListener &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBListener,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_SetListener(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
lldb::SBListener *arg2 = 0 ;
SWIG_check_num_args("lldb::SBLaunchInfo::SetListener",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetListener",1,"lldb::SBLaunchInfo *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetListener",2,"lldb::SBListener &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_SetListener",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBLaunchInfo_SetListener",2,SWIGTYPE_p_lldb__SBListener);
}
(arg1)->SetListener(*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetNumArguments(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBLaunchInfo::GetNumArguments",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetNumArguments",1,"lldb::SBLaunchInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetNumArguments",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (uint32_t)(arg1)->GetNumArguments();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetArgumentAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
uint32_t arg2 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBLaunchInfo::GetArgumentAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetArgumentAtIndex",1,"lldb::SBLaunchInfo *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::GetArgumentAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetArgumentAtIndex",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (char *)(arg1)->GetArgumentAtIndex(arg2);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_SetArguments(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
char **arg2 = (char **) 0 ;
bool arg3 ;
SWIG_check_num_args("lldb::SBLaunchInfo::SetArguments",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetArguments",1,"lldb::SBLaunchInfo *");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBLaunchInfo::SetArguments",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_SetArguments",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
{
if (lua_istable(L, 2)) {
size_t size = lua_rawlen(L, 2);
arg2 = (char **)malloc((size + 1) * sizeof(char *));
int i = 0, j = 0;
while (i++ < size) {
lua_rawgeti(L, 2, i);
if (!lua_isstring(L, -1)) {
// if current element cannot be converted to string, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain strings");
}
arg2[j++] = (char *)lua_tostring(L, -1);
lua_pop(L, 1);
}
arg2[j] = 0;
} else if (lua_isnil(L, 2)) {
// "nil" is also acceptable, equivalent as an empty table
arg2 = NULL;
} else {
return luaL_error(L, "A list of strings expected");
}
}
arg3 = (lua_toboolean(L, 3)!=0);
(arg1)->SetArguments((char const **)arg2,arg3);
{
free((char *) arg2);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free((char *) arg2);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetNumEnvironmentEntries(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBLaunchInfo::GetNumEnvironmentEntries",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetNumEnvironmentEntries",1,"lldb::SBLaunchInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetNumEnvironmentEntries",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (uint32_t)(arg1)->GetNumEnvironmentEntries();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetEnvironmentEntryAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
uint32_t arg2 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBLaunchInfo::GetEnvironmentEntryAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetEnvironmentEntryAtIndex",1,"lldb::SBLaunchInfo *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::GetEnvironmentEntryAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetEnvironmentEntryAtIndex",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (char *)(arg1)->GetEnvironmentEntryAtIndex(arg2);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_SetEnvironmentEntries(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
char **arg2 = (char **) 0 ;
bool arg3 ;
SWIG_check_num_args("lldb::SBLaunchInfo::SetEnvironmentEntries",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetEnvironmentEntries",1,"lldb::SBLaunchInfo *");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBLaunchInfo::SetEnvironmentEntries",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_SetEnvironmentEntries",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
{
if (lua_istable(L, 2)) {
size_t size = lua_rawlen(L, 2);
arg2 = (char **)malloc((size + 1) * sizeof(char *));
int i = 0, j = 0;
while (i++ < size) {
lua_rawgeti(L, 2, i);
if (!lua_isstring(L, -1)) {
// if current element cannot be converted to string, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain strings");
}
arg2[j++] = (char *)lua_tostring(L, -1);
lua_pop(L, 1);
}
arg2[j] = 0;
} else if (lua_isnil(L, 2)) {
// "nil" is also acceptable, equivalent as an empty table
arg2 = NULL;
} else {
return luaL_error(L, "A list of strings expected");
}
}
arg3 = (lua_toboolean(L, 3)!=0);
(arg1)->SetEnvironmentEntries((char const **)arg2,arg3);
{
free((char *) arg2);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free((char *) arg2);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_SetEnvironment(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
lldb::SBEnvironment *arg2 = 0 ;
bool arg3 ;
SWIG_check_num_args("lldb::SBLaunchInfo::SetEnvironment",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetEnvironment",1,"lldb::SBLaunchInfo *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetEnvironment",2,"lldb::SBEnvironment const &");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBLaunchInfo::SetEnvironment",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_SetEnvironment",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEnvironment,0))){
SWIG_fail_ptr("SBLaunchInfo_SetEnvironment",2,SWIGTYPE_p_lldb__SBEnvironment);
}
arg3 = (lua_toboolean(L, 3)!=0);
(arg1)->SetEnvironment((lldb::SBEnvironment const &)*arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetEnvironment(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
lldb::SBEnvironment result;
SWIG_check_num_args("lldb::SBLaunchInfo::GetEnvironment",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetEnvironment",1,"lldb::SBLaunchInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetEnvironment",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (arg1)->GetEnvironment();
{
lldb::SBEnvironment * resultptr = new lldb::SBEnvironment((const lldb::SBEnvironment &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBEnvironment,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
SWIG_check_num_args("lldb::SBLaunchInfo::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::Clear",1,"lldb::SBLaunchInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_Clear",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetWorkingDirectory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBLaunchInfo::GetWorkingDirectory",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetWorkingDirectory",1,"lldb::SBLaunchInfo const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetWorkingDirectory",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (char *)((lldb::SBLaunchInfo const *)arg1)->GetWorkingDirectory();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_SetWorkingDirectory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBLaunchInfo::SetWorkingDirectory",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetWorkingDirectory",1,"lldb::SBLaunchInfo *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetWorkingDirectory",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_SetWorkingDirectory",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetWorkingDirectory((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetLaunchFlags(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBLaunchInfo::GetLaunchFlags",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetLaunchFlags",1,"lldb::SBLaunchInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetLaunchFlags",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (uint32_t)(arg1)->GetLaunchFlags();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_SetLaunchFlags(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBLaunchInfo::SetLaunchFlags",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetLaunchFlags",1,"lldb::SBLaunchInfo *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetLaunchFlags",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_SetLaunchFlags",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetLaunchFlags(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetProcessPluginName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBLaunchInfo::GetProcessPluginName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetProcessPluginName",1,"lldb::SBLaunchInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetProcessPluginName",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (char *)(arg1)->GetProcessPluginName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_SetProcessPluginName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBLaunchInfo::SetProcessPluginName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetProcessPluginName",1,"lldb::SBLaunchInfo *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetProcessPluginName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_SetProcessPluginName",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetProcessPluginName((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetShell(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBLaunchInfo::GetShell",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetShell",1,"lldb::SBLaunchInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetShell",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (char *)(arg1)->GetShell();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_SetShell(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBLaunchInfo::SetShell",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetShell",1,"lldb::SBLaunchInfo *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetShell",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_SetShell",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetShell((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetShellExpandArguments(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBLaunchInfo::GetShellExpandArguments",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetShellExpandArguments",1,"lldb::SBLaunchInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetShellExpandArguments",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (bool)(arg1)->GetShellExpandArguments();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_SetShellExpandArguments(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBLaunchInfo::SetShellExpandArguments",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetShellExpandArguments",1,"lldb::SBLaunchInfo *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetShellExpandArguments",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_SetShellExpandArguments",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetShellExpandArguments(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetResumeCount(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBLaunchInfo::GetResumeCount",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetResumeCount",1,"lldb::SBLaunchInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetResumeCount",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (uint32_t)(arg1)->GetResumeCount();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_SetResumeCount(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBLaunchInfo::SetResumeCount",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetResumeCount",1,"lldb::SBLaunchInfo *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetResumeCount",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_SetResumeCount",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetResumeCount(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_AddCloseFileAction(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
int arg2 ;
bool result;
SWIG_check_num_args("lldb::SBLaunchInfo::AddCloseFileAction",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::AddCloseFileAction",1,"lldb::SBLaunchInfo *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::AddCloseFileAction",2,"int");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_AddCloseFileAction",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
arg2 = (int)lua_tointeger(L, 2);
result = (bool)(arg1)->AddCloseFileAction(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_AddDuplicateFileAction(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
int arg2 ;
int arg3 ;
bool result;
SWIG_check_num_args("lldb::SBLaunchInfo::AddDuplicateFileAction",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::AddDuplicateFileAction",1,"lldb::SBLaunchInfo *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::AddDuplicateFileAction",2,"int");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBLaunchInfo::AddDuplicateFileAction",3,"int");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_AddDuplicateFileAction",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
arg2 = (int)lua_tointeger(L, 2);
arg3 = (int)lua_tointeger(L, 3);
result = (bool)(arg1)->AddDuplicateFileAction(arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_AddOpenFileAction(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
int arg2 ;
char *arg3 = (char *) 0 ;
bool arg4 ;
bool arg5 ;
bool result;
SWIG_check_num_args("lldb::SBLaunchInfo::AddOpenFileAction",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::AddOpenFileAction",1,"lldb::SBLaunchInfo *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::AddOpenFileAction",2,"int");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBLaunchInfo::AddOpenFileAction",3,"char const *");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBLaunchInfo::AddOpenFileAction",4,"bool");
if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBLaunchInfo::AddOpenFileAction",5,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_AddOpenFileAction",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
arg2 = (int)lua_tointeger(L, 2);
arg3 = (char *)lua_tostring(L, 3);
arg4 = (lua_toboolean(L, 4)!=0);
arg5 = (lua_toboolean(L, 5)!=0);
result = (bool)(arg1)->AddOpenFileAction(arg2,(char const *)arg3,arg4,arg5);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_AddSuppressFileAction(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
int arg2 ;
bool arg3 ;
bool arg4 ;
bool result;
SWIG_check_num_args("lldb::SBLaunchInfo::AddSuppressFileAction",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::AddSuppressFileAction",1,"lldb::SBLaunchInfo *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::AddSuppressFileAction",2,"int");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBLaunchInfo::AddSuppressFileAction",3,"bool");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBLaunchInfo::AddSuppressFileAction",4,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_AddSuppressFileAction",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
arg2 = (int)lua_tointeger(L, 2);
arg3 = (lua_toboolean(L, 3)!=0);
arg4 = (lua_toboolean(L, 4)!=0);
result = (bool)(arg1)->AddSuppressFileAction(arg2,arg3,arg4);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_SetLaunchEventData(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBLaunchInfo::SetLaunchEventData",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetLaunchEventData",1,"lldb::SBLaunchInfo *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetLaunchEventData",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_SetLaunchEventData",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetLaunchEventData((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetLaunchEventData(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBLaunchInfo::GetLaunchEventData",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetLaunchEventData",1,"lldb::SBLaunchInfo const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetLaunchEventData",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (char *)((lldb::SBLaunchInfo const *)arg1)->GetLaunchEventData();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetDetachOnError(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBLaunchInfo::GetDetachOnError",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetDetachOnError",1,"lldb::SBLaunchInfo const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetDetachOnError",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (bool)((lldb::SBLaunchInfo const *)arg1)->GetDetachOnError();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_SetDetachOnError(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBLaunchInfo::SetDetachOnError",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetDetachOnError",1,"lldb::SBLaunchInfo *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetDetachOnError",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_SetDetachOnError",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetDetachOnError(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetScriptedProcessClassName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBLaunchInfo::GetScriptedProcessClassName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetScriptedProcessClassName",1,"lldb::SBLaunchInfo const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetScriptedProcessClassName",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (char *)((lldb::SBLaunchInfo const *)arg1)->GetScriptedProcessClassName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_SetScriptedProcessClassName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBLaunchInfo::SetScriptedProcessClassName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetScriptedProcessClassName",1,"lldb::SBLaunchInfo *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetScriptedProcessClassName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_SetScriptedProcessClassName",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetScriptedProcessClassName((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_GetScriptedProcessDictionary(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
lldb::SBStructuredData result;
SWIG_check_num_args("lldb::SBLaunchInfo::GetScriptedProcessDictionary",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetScriptedProcessDictionary",1,"lldb::SBLaunchInfo const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_GetScriptedProcessDictionary",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = ((lldb::SBLaunchInfo const *)arg1)->GetScriptedProcessDictionary();
{
lldb::SBStructuredData * resultptr = new lldb::SBStructuredData((const lldb::SBStructuredData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLaunchInfo_SetScriptedProcessDictionary(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ;
lldb::SBStructuredData arg2 ;
lldb::SBStructuredData *argp2 ;
SWIG_check_num_args("lldb::SBLaunchInfo::SetScriptedProcessDictionary",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetScriptedProcessDictionary",1,"lldb::SBLaunchInfo *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetScriptedProcessDictionary",2,"lldb::SBStructuredData");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBLaunchInfo_SetScriptedProcessDictionary",1,SWIGTYPE_p_lldb__SBLaunchInfo);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBLaunchInfo_SetScriptedProcessDictionary",2,SWIGTYPE_p_lldb__SBStructuredData);
}
arg2 = *argp2;
(arg1)->SetScriptedProcessDictionary(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBLaunchInfo(void *obj) {
lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBLaunchInfo(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBLaunchInfo);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBLaunchInfo_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBLaunchInfo_methods[]= {
{ "GetProcessID", _wrap_SBLaunchInfo_GetProcessID},
{ "GetUserID", _wrap_SBLaunchInfo_GetUserID},
{ "GetGroupID", _wrap_SBLaunchInfo_GetGroupID},
{ "UserIDIsValid", _wrap_SBLaunchInfo_UserIDIsValid},
{ "GroupIDIsValid", _wrap_SBLaunchInfo_GroupIDIsValid},
{ "SetUserID", _wrap_SBLaunchInfo_SetUserID},
{ "SetGroupID", _wrap_SBLaunchInfo_SetGroupID},
{ "GetExecutableFile", _wrap_SBLaunchInfo_GetExecutableFile},
{ "SetExecutableFile", _wrap_SBLaunchInfo_SetExecutableFile},
{ "GetListener", _wrap_SBLaunchInfo_GetListener},
{ "SetListener", _wrap_SBLaunchInfo_SetListener},
{ "GetNumArguments", _wrap_SBLaunchInfo_GetNumArguments},
{ "GetArgumentAtIndex", _wrap_SBLaunchInfo_GetArgumentAtIndex},
{ "SetArguments", _wrap_SBLaunchInfo_SetArguments},
{ "GetNumEnvironmentEntries", _wrap_SBLaunchInfo_GetNumEnvironmentEntries},
{ "GetEnvironmentEntryAtIndex", _wrap_SBLaunchInfo_GetEnvironmentEntryAtIndex},
{ "SetEnvironmentEntries", _wrap_SBLaunchInfo_SetEnvironmentEntries},
{ "SetEnvironment", _wrap_SBLaunchInfo_SetEnvironment},
{ "GetEnvironment", _wrap_SBLaunchInfo_GetEnvironment},
{ "Clear", _wrap_SBLaunchInfo_Clear},
{ "GetWorkingDirectory", _wrap_SBLaunchInfo_GetWorkingDirectory},
{ "SetWorkingDirectory", _wrap_SBLaunchInfo_SetWorkingDirectory},
{ "GetLaunchFlags", _wrap_SBLaunchInfo_GetLaunchFlags},
{ "SetLaunchFlags", _wrap_SBLaunchInfo_SetLaunchFlags},
{ "GetProcessPluginName", _wrap_SBLaunchInfo_GetProcessPluginName},
{ "SetProcessPluginName", _wrap_SBLaunchInfo_SetProcessPluginName},
{ "GetShell", _wrap_SBLaunchInfo_GetShell},
{ "SetShell", _wrap_SBLaunchInfo_SetShell},
{ "GetShellExpandArguments", _wrap_SBLaunchInfo_GetShellExpandArguments},
{ "SetShellExpandArguments", _wrap_SBLaunchInfo_SetShellExpandArguments},
{ "GetResumeCount", _wrap_SBLaunchInfo_GetResumeCount},
{ "SetResumeCount", _wrap_SBLaunchInfo_SetResumeCount},
{ "AddCloseFileAction", _wrap_SBLaunchInfo_AddCloseFileAction},
{ "AddDuplicateFileAction", _wrap_SBLaunchInfo_AddDuplicateFileAction},
{ "AddOpenFileAction", _wrap_SBLaunchInfo_AddOpenFileAction},
{ "AddSuppressFileAction", _wrap_SBLaunchInfo_AddSuppressFileAction},
{ "SetLaunchEventData", _wrap_SBLaunchInfo_SetLaunchEventData},
{ "GetLaunchEventData", _wrap_SBLaunchInfo_GetLaunchEventData},
{ "GetDetachOnError", _wrap_SBLaunchInfo_GetDetachOnError},
{ "SetDetachOnError", _wrap_SBLaunchInfo_SetDetachOnError},
{ "GetScriptedProcessClassName", _wrap_SBLaunchInfo_GetScriptedProcessClassName},
{ "SetScriptedProcessClassName", _wrap_SBLaunchInfo_SetScriptedProcessClassName},
{ "GetScriptedProcessDictionary", _wrap_SBLaunchInfo_GetScriptedProcessDictionary},
{ "SetScriptedProcessDictionary", _wrap_SBLaunchInfo_SetScriptedProcessDictionary},
{0,0}
};
static swig_lua_method swig_SBLaunchInfo_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBLaunchInfo_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBLaunchInfo_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBLaunchInfo_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBLaunchInfo_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBLaunchInfo_Sf_SwigStatic = {
"SBLaunchInfo",
swig_SBLaunchInfo_Sf_SwigStatic_methods,
swig_SBLaunchInfo_Sf_SwigStatic_attributes,
swig_SBLaunchInfo_Sf_SwigStatic_constants,
swig_SBLaunchInfo_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBLaunchInfo_bases[] = {0};
static const char *swig_SBLaunchInfo_base_names[] = {0};
static swig_lua_class _wrap_class_SBLaunchInfo = { "SBLaunchInfo", "SBLaunchInfo", &SWIGTYPE_p_lldb__SBLaunchInfo,_proxy__wrap_new_SBLaunchInfo, swig_delete_SBLaunchInfo, swig_SBLaunchInfo_methods, swig_SBLaunchInfo_attributes, &swig_SBLaunchInfo_Sf_SwigStatic, swig_SBLaunchInfo_meta, swig_SBLaunchInfo_bases, swig_SBLaunchInfo_base_names };
static int _wrap_new_SBLineEntry__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLineEntry *result = 0 ;
SWIG_check_num_args("lldb::SBLineEntry::SBLineEntry",0,0)
result = (lldb::SBLineEntry *)new lldb::SBLineEntry();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBLineEntry,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBLineEntry__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLineEntry *arg1 = 0 ;
lldb::SBLineEntry *result = 0 ;
SWIG_check_num_args("lldb::SBLineEntry::SBLineEntry",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBLineEntry::SBLineEntry",1,"lldb::SBLineEntry const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){
SWIG_fail_ptr("new_SBLineEntry",1,SWIGTYPE_p_lldb__SBLineEntry);
}
result = (lldb::SBLineEntry *)new lldb::SBLineEntry((lldb::SBLineEntry const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBLineEntry,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBLineEntry(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBLineEntry__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBLineEntry, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBLineEntry__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBLineEntry'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBLineEntry::SBLineEntry()\n"
" lldb::SBLineEntry::SBLineEntry(lldb::SBLineEntry const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBLineEntry_GetStartAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBLineEntry::GetStartAddress",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::GetStartAddress",1,"lldb::SBLineEntry const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){
SWIG_fail_ptr("SBLineEntry_GetStartAddress",1,SWIGTYPE_p_lldb__SBLineEntry);
}
result = ((lldb::SBLineEntry const *)arg1)->GetStartAddress();
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLineEntry_GetEndAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBLineEntry::GetEndAddress",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::GetEndAddress",1,"lldb::SBLineEntry const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){
SWIG_fail_ptr("SBLineEntry_GetEndAddress",1,SWIGTYPE_p_lldb__SBLineEntry);
}
result = ((lldb::SBLineEntry const *)arg1)->GetEndAddress();
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLineEntry_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBLineEntry::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::IsValid",1,"lldb::SBLineEntry const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){
SWIG_fail_ptr("SBLineEntry_IsValid",1,SWIGTYPE_p_lldb__SBLineEntry);
}
result = (bool)((lldb::SBLineEntry const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLineEntry_GetFileSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBLineEntry::GetFileSpec",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::GetFileSpec",1,"lldb::SBLineEntry const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){
SWIG_fail_ptr("SBLineEntry_GetFileSpec",1,SWIGTYPE_p_lldb__SBLineEntry);
}
result = ((lldb::SBLineEntry const *)arg1)->GetFileSpec();
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLineEntry_GetLine(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBLineEntry::GetLine",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::GetLine",1,"lldb::SBLineEntry const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){
SWIG_fail_ptr("SBLineEntry_GetLine",1,SWIGTYPE_p_lldb__SBLineEntry);
}
result = (uint32_t)((lldb::SBLineEntry const *)arg1)->GetLine();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLineEntry_GetColumn(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBLineEntry::GetColumn",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::GetColumn",1,"lldb::SBLineEntry const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){
SWIG_fail_ptr("SBLineEntry_GetColumn",1,SWIGTYPE_p_lldb__SBLineEntry);
}
result = (uint32_t)((lldb::SBLineEntry const *)arg1)->GetColumn();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLineEntry_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBLineEntry::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::GetDescription",1,"lldb::SBLineEntry *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBLineEntry::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){
SWIG_fail_ptr("SBLineEntry_GetDescription",1,SWIGTYPE_p_lldb__SBLineEntry);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBLineEntry_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLineEntry_SetFileSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ;
lldb::SBFileSpec arg2 ;
lldb::SBFileSpec *argp2 ;
SWIG_check_num_args("lldb::SBLineEntry::SetFileSpec",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::SetFileSpec",1,"lldb::SBLineEntry *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBLineEntry::SetFileSpec",2,"lldb::SBFileSpec");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){
SWIG_fail_ptr("SBLineEntry_SetFileSpec",1,SWIGTYPE_p_lldb__SBLineEntry);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBLineEntry_SetFileSpec",2,SWIGTYPE_p_lldb__SBFileSpec);
}
arg2 = *argp2;
(arg1)->SetFileSpec(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLineEntry_SetLine(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBLineEntry::SetLine",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::SetLine",1,"lldb::SBLineEntry *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLineEntry::SetLine",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){
SWIG_fail_ptr("SBLineEntry_SetLine",1,SWIGTYPE_p_lldb__SBLineEntry);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetLine(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLineEntry_SetColumn(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBLineEntry::SetColumn",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::SetColumn",1,"lldb::SBLineEntry *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLineEntry::SetColumn",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){
SWIG_fail_ptr("SBLineEntry_SetColumn",1,SWIGTYPE_p_lldb__SBLineEntry);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetColumn(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLineEntry___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ;
lldb::SBLineEntry *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBLineEntry::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::operator ==",1,"lldb::SBLineEntry const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBLineEntry::operator ==",2,"lldb::SBLineEntry const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){
SWIG_fail_ptr("SBLineEntry___eq",1,SWIGTYPE_p_lldb__SBLineEntry);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBLineEntry,0))){
SWIG_fail_ptr("SBLineEntry___eq",2,SWIGTYPE_p_lldb__SBLineEntry);
}
result = (bool)((lldb::SBLineEntry const *)arg1)->operator ==((lldb::SBLineEntry const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBLineEntry___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBLineEntry::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::__str__",1,"lldb::SBLineEntry *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){
SWIG_fail_ptr("SBLineEntry___tostring",1,SWIGTYPE_p_lldb__SBLineEntry);
}
result = lldb_SBLineEntry___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBLineEntry(void *obj) {
lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBLineEntry(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBLineEntry);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBLineEntry_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBLineEntry_methods[]= {
{ "GetStartAddress", _wrap_SBLineEntry_GetStartAddress},
{ "GetEndAddress", _wrap_SBLineEntry_GetEndAddress},
{ "IsValid", _wrap_SBLineEntry_IsValid},
{ "GetFileSpec", _wrap_SBLineEntry_GetFileSpec},
{ "GetLine", _wrap_SBLineEntry_GetLine},
{ "GetColumn", _wrap_SBLineEntry_GetColumn},
{ "GetDescription", _wrap_SBLineEntry_GetDescription},
{ "SetFileSpec", _wrap_SBLineEntry_SetFileSpec},
{ "SetLine", _wrap_SBLineEntry_SetLine},
{ "SetColumn", _wrap_SBLineEntry_SetColumn},
{ "__eq", _wrap_SBLineEntry___eq},
{ "__tostring", _wrap_SBLineEntry___tostring},
{0,0}
};
static swig_lua_method swig_SBLineEntry_meta[] = {
{ "__eq", _wrap_SBLineEntry___eq},
{ "__tostring", _wrap_SBLineEntry___tostring},
{0,0}
};
static swig_lua_attribute swig_SBLineEntry_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBLineEntry_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBLineEntry_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBLineEntry_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBLineEntry_Sf_SwigStatic = {
"SBLineEntry",
swig_SBLineEntry_Sf_SwigStatic_methods,
swig_SBLineEntry_Sf_SwigStatic_attributes,
swig_SBLineEntry_Sf_SwigStatic_constants,
swig_SBLineEntry_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBLineEntry_bases[] = {0};
static const char *swig_SBLineEntry_base_names[] = {0};
static swig_lua_class _wrap_class_SBLineEntry = { "SBLineEntry", "SBLineEntry", &SWIGTYPE_p_lldb__SBLineEntry,_proxy__wrap_new_SBLineEntry, swig_delete_SBLineEntry, swig_SBLineEntry_methods, swig_SBLineEntry_attributes, &swig_SBLineEntry_Sf_SwigStatic, swig_SBLineEntry_meta, swig_SBLineEntry_bases, swig_SBLineEntry_base_names };
static int _wrap_new_SBListener__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *result = 0 ;
SWIG_check_num_args("lldb::SBListener::SBListener",0,0)
result = (lldb::SBListener *)new lldb::SBListener();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBListener,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBListener__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
lldb::SBListener *result = 0 ;
SWIG_check_num_args("lldb::SBListener::SBListener",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBListener::SBListener",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = (lldb::SBListener *)new lldb::SBListener((char const *)arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBListener,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBListener__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *arg1 = 0 ;
lldb::SBListener *result = 0 ;
SWIG_check_num_args("lldb::SBListener::SBListener",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBListener::SBListener",1,"lldb::SBListener const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("new_SBListener",1,SWIGTYPE_p_lldb__SBListener);
}
result = (lldb::SBListener *)new lldb::SBListener((lldb::SBListener const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBListener,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBListener(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBListener__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBListener__SWIG_2(L);
}
}
if (argc == 1) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
return _wrap_new_SBListener__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBListener'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBListener::SBListener()\n"
" lldb::SBListener::SBListener(char const *)\n"
" lldb::SBListener::SBListener(lldb::SBListener const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBListener_AddEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *arg1 = (lldb::SBListener *) 0 ;
lldb::SBEvent *arg2 = 0 ;
SWIG_check_num_args("lldb::SBListener::AddEvent",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::AddEvent",1,"lldb::SBListener *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::AddEvent",2,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBListener_AddEvent",1,SWIGTYPE_p_lldb__SBListener);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBListener_AddEvent",2,SWIGTYPE_p_lldb__SBEvent);
}
(arg1)->AddEvent((lldb::SBEvent const &)*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBListener_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *arg1 = (lldb::SBListener *) 0 ;
SWIG_check_num_args("lldb::SBListener::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::Clear",1,"lldb::SBListener *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBListener_Clear",1,SWIGTYPE_p_lldb__SBListener);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBListener_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *arg1 = (lldb::SBListener *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBListener::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::IsValid",1,"lldb::SBListener const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBListener_IsValid",1,SWIGTYPE_p_lldb__SBListener);
}
result = (bool)((lldb::SBListener const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBListener_StartListeningForEventClass(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *arg1 = (lldb::SBListener *) 0 ;
lldb::SBDebugger *arg2 = 0 ;
char *arg3 = (char *) 0 ;
uint32_t arg4 ;
uint32_t result;
SWIG_check_num_args("lldb::SBListener::StartListeningForEventClass",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::StartListeningForEventClass",1,"lldb::SBListener *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::StartListeningForEventClass",2,"lldb::SBDebugger &");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBListener::StartListeningForEventClass",3,"char const *");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBListener::StartListeningForEventClass",4,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBListener_StartListeningForEventClass",1,SWIGTYPE_p_lldb__SBListener);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBListener_StartListeningForEventClass",2,SWIGTYPE_p_lldb__SBDebugger);
}
arg3 = (char *)lua_tostring(L, 3);
arg4 = (uint32_t)lua_tointeger(L, 4);
result = (uint32_t)(arg1)->StartListeningForEventClass(*arg2,(char const *)arg3,arg4);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBListener_StopListeningForEventClass(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *arg1 = (lldb::SBListener *) 0 ;
lldb::SBDebugger *arg2 = 0 ;
char *arg3 = (char *) 0 ;
uint32_t arg4 ;
uint32_t result;
SWIG_check_num_args("lldb::SBListener::StopListeningForEventClass",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::StopListeningForEventClass",1,"lldb::SBListener *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::StopListeningForEventClass",2,"lldb::SBDebugger &");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBListener::StopListeningForEventClass",3,"char const *");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBListener::StopListeningForEventClass",4,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBListener_StopListeningForEventClass",1,SWIGTYPE_p_lldb__SBListener);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBDebugger,0))){
SWIG_fail_ptr("SBListener_StopListeningForEventClass",2,SWIGTYPE_p_lldb__SBDebugger);
}
arg3 = (char *)lua_tostring(L, 3);
arg4 = (uint32_t)lua_tointeger(L, 4);
result = (uint32_t)(arg1)->StopListeningForEventClass(*arg2,(char const *)arg3,arg4);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBListener_StartListeningForEvents(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *arg1 = (lldb::SBListener *) 0 ;
lldb::SBBroadcaster *arg2 = 0 ;
uint32_t arg3 ;
uint32_t result;
SWIG_check_num_args("lldb::SBListener::StartListeningForEvents",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::StartListeningForEvents",1,"lldb::SBListener *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::StartListeningForEvents",2,"lldb::SBBroadcaster const &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBListener::StartListeningForEvents",3,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBListener_StartListeningForEvents",1,SWIGTYPE_p_lldb__SBListener);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBListener_StartListeningForEvents",2,SWIGTYPE_p_lldb__SBBroadcaster);
}
arg3 = (uint32_t)lua_tointeger(L, 3);
result = (uint32_t)(arg1)->StartListeningForEvents((lldb::SBBroadcaster const &)*arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBListener_StopListeningForEvents(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *arg1 = (lldb::SBListener *) 0 ;
lldb::SBBroadcaster *arg2 = 0 ;
uint32_t arg3 ;
bool result;
SWIG_check_num_args("lldb::SBListener::StopListeningForEvents",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::StopListeningForEvents",1,"lldb::SBListener *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::StopListeningForEvents",2,"lldb::SBBroadcaster const &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBListener::StopListeningForEvents",3,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBListener_StopListeningForEvents",1,SWIGTYPE_p_lldb__SBListener);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBListener_StopListeningForEvents",2,SWIGTYPE_p_lldb__SBBroadcaster);
}
arg3 = (uint32_t)lua_tointeger(L, 3);
result = (bool)(arg1)->StopListeningForEvents((lldb::SBBroadcaster const &)*arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBListener_WaitForEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *arg1 = (lldb::SBListener *) 0 ;
uint32_t arg2 ;
lldb::SBEvent *arg3 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBListener::WaitForEvent",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::WaitForEvent",1,"lldb::SBListener *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBListener::WaitForEvent",2,"uint32_t");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBListener::WaitForEvent",3,"lldb::SBEvent &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBListener_WaitForEvent",1,SWIGTYPE_p_lldb__SBListener);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBListener_WaitForEvent",3,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)(arg1)->WaitForEvent(arg2,*arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBListener_WaitForEventForBroadcaster(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *arg1 = (lldb::SBListener *) 0 ;
uint32_t arg2 ;
lldb::SBBroadcaster *arg3 = 0 ;
lldb::SBEvent *arg4 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBListener::WaitForEventForBroadcaster",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::WaitForEventForBroadcaster",1,"lldb::SBListener *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBListener::WaitForEventForBroadcaster",2,"uint32_t");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBListener::WaitForEventForBroadcaster",3,"lldb::SBBroadcaster const &");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBListener::WaitForEventForBroadcaster",4,"lldb::SBEvent &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBListener_WaitForEventForBroadcaster",1,SWIGTYPE_p_lldb__SBListener);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBListener_WaitForEventForBroadcaster",3,SWIGTYPE_p_lldb__SBBroadcaster);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBListener_WaitForEventForBroadcaster",4,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)(arg1)->WaitForEventForBroadcaster(arg2,(lldb::SBBroadcaster const &)*arg3,*arg4);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBListener_WaitForEventForBroadcasterWithType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *arg1 = (lldb::SBListener *) 0 ;
uint32_t arg2 ;
lldb::SBBroadcaster *arg3 = 0 ;
uint32_t arg4 ;
lldb::SBEvent *arg5 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBListener::WaitForEventForBroadcasterWithType",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::WaitForEventForBroadcasterWithType",1,"lldb::SBListener *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBListener::WaitForEventForBroadcasterWithType",2,"uint32_t");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBListener::WaitForEventForBroadcasterWithType",3,"lldb::SBBroadcaster const &");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBListener::WaitForEventForBroadcasterWithType",4,"uint32_t");
if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBListener::WaitForEventForBroadcasterWithType",5,"lldb::SBEvent &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBListener_WaitForEventForBroadcasterWithType",1,SWIGTYPE_p_lldb__SBListener);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBListener_WaitForEventForBroadcasterWithType",3,SWIGTYPE_p_lldb__SBBroadcaster);
}
arg4 = (uint32_t)lua_tointeger(L, 4);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBListener_WaitForEventForBroadcasterWithType",5,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)(arg1)->WaitForEventForBroadcasterWithType(arg2,(lldb::SBBroadcaster const &)*arg3,arg4,*arg5);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBListener_PeekAtNextEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *arg1 = (lldb::SBListener *) 0 ;
lldb::SBEvent *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBListener::PeekAtNextEvent",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::PeekAtNextEvent",1,"lldb::SBListener *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::PeekAtNextEvent",2,"lldb::SBEvent &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBListener_PeekAtNextEvent",1,SWIGTYPE_p_lldb__SBListener);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBListener_PeekAtNextEvent",2,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)(arg1)->PeekAtNextEvent(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBListener_PeekAtNextEventForBroadcaster(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *arg1 = (lldb::SBListener *) 0 ;
lldb::SBBroadcaster *arg2 = 0 ;
lldb::SBEvent *arg3 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBListener::PeekAtNextEventForBroadcaster",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::PeekAtNextEventForBroadcaster",1,"lldb::SBListener *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::PeekAtNextEventForBroadcaster",2,"lldb::SBBroadcaster const &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBListener::PeekAtNextEventForBroadcaster",3,"lldb::SBEvent &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBListener_PeekAtNextEventForBroadcaster",1,SWIGTYPE_p_lldb__SBListener);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBListener_PeekAtNextEventForBroadcaster",2,SWIGTYPE_p_lldb__SBBroadcaster);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBListener_PeekAtNextEventForBroadcaster",3,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)(arg1)->PeekAtNextEventForBroadcaster((lldb::SBBroadcaster const &)*arg2,*arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBListener_PeekAtNextEventForBroadcasterWithType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *arg1 = (lldb::SBListener *) 0 ;
lldb::SBBroadcaster *arg2 = 0 ;
uint32_t arg3 ;
lldb::SBEvent *arg4 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBListener::PeekAtNextEventForBroadcasterWithType",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::PeekAtNextEventForBroadcasterWithType",1,"lldb::SBListener *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::PeekAtNextEventForBroadcasterWithType",2,"lldb::SBBroadcaster const &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBListener::PeekAtNextEventForBroadcasterWithType",3,"uint32_t");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBListener::PeekAtNextEventForBroadcasterWithType",4,"lldb::SBEvent &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBListener_PeekAtNextEventForBroadcasterWithType",1,SWIGTYPE_p_lldb__SBListener);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBListener_PeekAtNextEventForBroadcasterWithType",2,SWIGTYPE_p_lldb__SBBroadcaster);
}
arg3 = (uint32_t)lua_tointeger(L, 3);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBListener_PeekAtNextEventForBroadcasterWithType",4,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)(arg1)->PeekAtNextEventForBroadcasterWithType((lldb::SBBroadcaster const &)*arg2,arg3,*arg4);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBListener_GetNextEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *arg1 = (lldb::SBListener *) 0 ;
lldb::SBEvent *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBListener::GetNextEvent",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::GetNextEvent",1,"lldb::SBListener *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::GetNextEvent",2,"lldb::SBEvent &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBListener_GetNextEvent",1,SWIGTYPE_p_lldb__SBListener);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBListener_GetNextEvent",2,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)(arg1)->GetNextEvent(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBListener_GetNextEventForBroadcaster(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *arg1 = (lldb::SBListener *) 0 ;
lldb::SBBroadcaster *arg2 = 0 ;
lldb::SBEvent *arg3 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBListener::GetNextEventForBroadcaster",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::GetNextEventForBroadcaster",1,"lldb::SBListener *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::GetNextEventForBroadcaster",2,"lldb::SBBroadcaster const &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBListener::GetNextEventForBroadcaster",3,"lldb::SBEvent &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBListener_GetNextEventForBroadcaster",1,SWIGTYPE_p_lldb__SBListener);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBListener_GetNextEventForBroadcaster",2,SWIGTYPE_p_lldb__SBBroadcaster);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBListener_GetNextEventForBroadcaster",3,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)(arg1)->GetNextEventForBroadcaster((lldb::SBBroadcaster const &)*arg2,*arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBListener_GetNextEventForBroadcasterWithType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *arg1 = (lldb::SBListener *) 0 ;
lldb::SBBroadcaster *arg2 = 0 ;
uint32_t arg3 ;
lldb::SBEvent *arg4 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBListener::GetNextEventForBroadcasterWithType",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::GetNextEventForBroadcasterWithType",1,"lldb::SBListener *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::GetNextEventForBroadcasterWithType",2,"lldb::SBBroadcaster const &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBListener::GetNextEventForBroadcasterWithType",3,"uint32_t");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBListener::GetNextEventForBroadcasterWithType",4,"lldb::SBEvent &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBListener_GetNextEventForBroadcasterWithType",1,SWIGTYPE_p_lldb__SBListener);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBroadcaster,0))){
SWIG_fail_ptr("SBListener_GetNextEventForBroadcasterWithType",2,SWIGTYPE_p_lldb__SBBroadcaster);
}
arg3 = (uint32_t)lua_tointeger(L, 3);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBListener_GetNextEventForBroadcasterWithType",4,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)(arg1)->GetNextEventForBroadcasterWithType((lldb::SBBroadcaster const &)*arg2,arg3,*arg4);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBListener_HandleBroadcastEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBListener *arg1 = (lldb::SBListener *) 0 ;
lldb::SBEvent *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBListener::HandleBroadcastEvent",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::HandleBroadcastEvent",1,"lldb::SBListener *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::HandleBroadcastEvent",2,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBListener_HandleBroadcastEvent",1,SWIGTYPE_p_lldb__SBListener);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBListener_HandleBroadcastEvent",2,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)(arg1)->HandleBroadcastEvent((lldb::SBEvent const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBListener(void *obj) {
lldb::SBListener *arg1 = (lldb::SBListener *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBListener(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBListener);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBListener_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBListener_methods[]= {
{ "AddEvent", _wrap_SBListener_AddEvent},
{ "Clear", _wrap_SBListener_Clear},
{ "IsValid", _wrap_SBListener_IsValid},
{ "StartListeningForEventClass", _wrap_SBListener_StartListeningForEventClass},
{ "StopListeningForEventClass", _wrap_SBListener_StopListeningForEventClass},
{ "StartListeningForEvents", _wrap_SBListener_StartListeningForEvents},
{ "StopListeningForEvents", _wrap_SBListener_StopListeningForEvents},
{ "WaitForEvent", _wrap_SBListener_WaitForEvent},
{ "WaitForEventForBroadcaster", _wrap_SBListener_WaitForEventForBroadcaster},
{ "WaitForEventForBroadcasterWithType", _wrap_SBListener_WaitForEventForBroadcasterWithType},
{ "PeekAtNextEvent", _wrap_SBListener_PeekAtNextEvent},
{ "PeekAtNextEventForBroadcaster", _wrap_SBListener_PeekAtNextEventForBroadcaster},
{ "PeekAtNextEventForBroadcasterWithType", _wrap_SBListener_PeekAtNextEventForBroadcasterWithType},
{ "GetNextEvent", _wrap_SBListener_GetNextEvent},
{ "GetNextEventForBroadcaster", _wrap_SBListener_GetNextEventForBroadcaster},
{ "GetNextEventForBroadcasterWithType", _wrap_SBListener_GetNextEventForBroadcasterWithType},
{ "HandleBroadcastEvent", _wrap_SBListener_HandleBroadcastEvent},
{0,0}
};
static swig_lua_method swig_SBListener_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBListener_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBListener_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBListener_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBListener_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBListener_Sf_SwigStatic = {
"SBListener",
swig_SBListener_Sf_SwigStatic_methods,
swig_SBListener_Sf_SwigStatic_attributes,
swig_SBListener_Sf_SwigStatic_constants,
swig_SBListener_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBListener_bases[] = {0};
static const char *swig_SBListener_base_names[] = {0};
static swig_lua_class _wrap_class_SBListener = { "SBListener", "SBListener", &SWIGTYPE_p_lldb__SBListener,_proxy__wrap_new_SBListener, swig_delete_SBListener, swig_SBListener_methods, swig_SBListener_attributes, &swig_SBListener_Sf_SwigStatic, swig_SBListener_meta, swig_SBListener_bases, swig_SBListener_base_names };
static int _wrap_new_SBMemoryRegionInfo__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfo *result = 0 ;
SWIG_check_num_args("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",0,0)
result = (lldb::SBMemoryRegionInfo *)new lldb::SBMemoryRegionInfo();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBMemoryRegionInfo,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBMemoryRegionInfo__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfo *arg1 = 0 ;
lldb::SBMemoryRegionInfo *result = 0 ;
SWIG_check_num_args("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",1,"lldb::SBMemoryRegionInfo const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("new_SBMemoryRegionInfo",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
result = (lldb::SBMemoryRegionInfo *)new lldb::SBMemoryRegionInfo((lldb::SBMemoryRegionInfo const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBMemoryRegionInfo,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBMemoryRegionInfo__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
lldb::addr_t arg2 ;
lldb::addr_t arg3 ;
uint32_t arg4 ;
bool arg5 ;
bool arg6 ;
lldb::SBMemoryRegionInfo *result = 0 ;
SWIG_check_num_args("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",6,6)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",1,"char const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",2,"lldb::addr_t");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",3,"lldb::addr_t");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",4,"uint32_t");
if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",5,"bool");
if(!lua_isboolean(L,6)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",6,"bool");
arg1 = (char *)lua_tostring(L, 1);
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
arg3 = (lldb::addr_t)lua_tointeger(L, 3);
arg4 = (uint32_t)lua_tointeger(L, 4);
arg5 = (lua_toboolean(L, 5)!=0);
arg6 = (lua_toboolean(L, 6)!=0);
result = (lldb::SBMemoryRegionInfo *)new lldb::SBMemoryRegionInfo((char const *)arg1,arg2,arg3,arg4,arg5,arg6);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBMemoryRegionInfo,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBMemoryRegionInfo(lua_State* L) {
int argc;
int argv[7]={
1,2,3,4,5,6,7
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBMemoryRegionInfo__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBMemoryRegionInfo, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBMemoryRegionInfo__SWIG_1(L);
}
}
if (argc == 6) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[3]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[4]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[5]);
}
if (_v) {
return _wrap_new_SBMemoryRegionInfo__SWIG_2(L);
}
}
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBMemoryRegionInfo'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBMemoryRegionInfo::SBMemoryRegionInfo()\n"
" lldb::SBMemoryRegionInfo::SBMemoryRegionInfo(lldb::SBMemoryRegionInfo const &)\n"
" lldb::SBMemoryRegionInfo::SBMemoryRegionInfo(char const *,lldb::addr_t,lldb::addr_t,uint32_t,bool,bool)\n");
lua_error(L);return 0;
}
static int _wrap_SBMemoryRegionInfo_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ;
SWIG_check_num_args("lldb::SBMemoryRegionInfo::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::Clear",1,"lldb::SBMemoryRegionInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfo_Clear",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfo_GetRegionBase(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBMemoryRegionInfo::GetRegionBase",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::GetRegionBase",1,"lldb::SBMemoryRegionInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfo_GetRegionBase",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
result = (lldb::addr_t)(arg1)->GetRegionBase();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfo_GetRegionEnd(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBMemoryRegionInfo::GetRegionEnd",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::GetRegionEnd",1,"lldb::SBMemoryRegionInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfo_GetRegionEnd",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
result = (lldb::addr_t)(arg1)->GetRegionEnd();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfo_IsReadable(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBMemoryRegionInfo::IsReadable",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::IsReadable",1,"lldb::SBMemoryRegionInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfo_IsReadable",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
result = (bool)(arg1)->IsReadable();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfo_IsWritable(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBMemoryRegionInfo::IsWritable",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::IsWritable",1,"lldb::SBMemoryRegionInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfo_IsWritable",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
result = (bool)(arg1)->IsWritable();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfo_IsExecutable(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBMemoryRegionInfo::IsExecutable",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::IsExecutable",1,"lldb::SBMemoryRegionInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfo_IsExecutable",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
result = (bool)(arg1)->IsExecutable();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfo_IsMapped(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBMemoryRegionInfo::IsMapped",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::IsMapped",1,"lldb::SBMemoryRegionInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfo_IsMapped",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
result = (bool)(arg1)->IsMapped();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfo_GetName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBMemoryRegionInfo::GetName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::GetName",1,"lldb::SBMemoryRegionInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfo_GetName",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
result = (char *)(arg1)->GetName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfo_HasDirtyMemoryPageList(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBMemoryRegionInfo::HasDirtyMemoryPageList",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::HasDirtyMemoryPageList",1,"lldb::SBMemoryRegionInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfo_HasDirtyMemoryPageList",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
result = (bool)(arg1)->HasDirtyMemoryPageList();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfo_GetNumDirtyPages(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBMemoryRegionInfo::GetNumDirtyPages",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::GetNumDirtyPages",1,"lldb::SBMemoryRegionInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfo_GetNumDirtyPages",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
result = (uint32_t)(arg1)->GetNumDirtyPages();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfo_GetDirtyPageAddressAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ;
uint32_t arg2 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBMemoryRegionInfo::GetDirtyPageAddressAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::GetDirtyPageAddressAtIndex",1,"lldb::SBMemoryRegionInfo *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::GetDirtyPageAddressAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfo_GetDirtyPageAddressAtIndex",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (lldb::addr_t)(arg1)->GetDirtyPageAddressAtIndex(arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfo_GetPageSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ;
int result;
SWIG_check_num_args("lldb::SBMemoryRegionInfo::GetPageSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::GetPageSize",1,"lldb::SBMemoryRegionInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfo_GetPageSize",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
result = (int)(arg1)->GetPageSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfo___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ;
lldb::SBMemoryRegionInfo *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBMemoryRegionInfo::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::operator ==",1,"lldb::SBMemoryRegionInfo const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::operator ==",2,"lldb::SBMemoryRegionInfo const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfo___eq",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfo___eq",2,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
result = (bool)((lldb::SBMemoryRegionInfo const *)arg1)->operator ==((lldb::SBMemoryRegionInfo const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfo_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBMemoryRegionInfo::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::GetDescription",1,"lldb::SBMemoryRegionInfo *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfo_GetDescription",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBMemoryRegionInfo_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfo___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBMemoryRegionInfo::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::__str__",1,"lldb::SBMemoryRegionInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfo___tostring",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
result = lldb_SBMemoryRegionInfo___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBMemoryRegionInfo(void *obj) {
lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBMemoryRegionInfo(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBMemoryRegionInfo);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBMemoryRegionInfo_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBMemoryRegionInfo_methods[]= {
{ "Clear", _wrap_SBMemoryRegionInfo_Clear},
{ "GetRegionBase", _wrap_SBMemoryRegionInfo_GetRegionBase},
{ "GetRegionEnd", _wrap_SBMemoryRegionInfo_GetRegionEnd},
{ "IsReadable", _wrap_SBMemoryRegionInfo_IsReadable},
{ "IsWritable", _wrap_SBMemoryRegionInfo_IsWritable},
{ "IsExecutable", _wrap_SBMemoryRegionInfo_IsExecutable},
{ "IsMapped", _wrap_SBMemoryRegionInfo_IsMapped},
{ "GetName", _wrap_SBMemoryRegionInfo_GetName},
{ "HasDirtyMemoryPageList", _wrap_SBMemoryRegionInfo_HasDirtyMemoryPageList},
{ "GetNumDirtyPages", _wrap_SBMemoryRegionInfo_GetNumDirtyPages},
{ "GetDirtyPageAddressAtIndex", _wrap_SBMemoryRegionInfo_GetDirtyPageAddressAtIndex},
{ "GetPageSize", _wrap_SBMemoryRegionInfo_GetPageSize},
{ "__eq", _wrap_SBMemoryRegionInfo___eq},
{ "GetDescription", _wrap_SBMemoryRegionInfo_GetDescription},
{ "__tostring", _wrap_SBMemoryRegionInfo___tostring},
{0,0}
};
static swig_lua_method swig_SBMemoryRegionInfo_meta[] = {
{ "__eq", _wrap_SBMemoryRegionInfo___eq},
{ "__tostring", _wrap_SBMemoryRegionInfo___tostring},
{0,0}
};
static swig_lua_attribute swig_SBMemoryRegionInfo_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBMemoryRegionInfo_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBMemoryRegionInfo_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBMemoryRegionInfo_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBMemoryRegionInfo_Sf_SwigStatic = {
"SBMemoryRegionInfo",
swig_SBMemoryRegionInfo_Sf_SwigStatic_methods,
swig_SBMemoryRegionInfo_Sf_SwigStatic_attributes,
swig_SBMemoryRegionInfo_Sf_SwigStatic_constants,
swig_SBMemoryRegionInfo_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBMemoryRegionInfo_bases[] = {0};
static const char *swig_SBMemoryRegionInfo_base_names[] = {0};
static swig_lua_class _wrap_class_SBMemoryRegionInfo = { "SBMemoryRegionInfo", "SBMemoryRegionInfo", &SWIGTYPE_p_lldb__SBMemoryRegionInfo,_proxy__wrap_new_SBMemoryRegionInfo, swig_delete_SBMemoryRegionInfo, swig_SBMemoryRegionInfo_methods, swig_SBMemoryRegionInfo_attributes, &swig_SBMemoryRegionInfo_Sf_SwigStatic, swig_SBMemoryRegionInfo_meta, swig_SBMemoryRegionInfo_bases, swig_SBMemoryRegionInfo_base_names };
static int _wrap_new_SBMemoryRegionInfoList__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfoList *result = 0 ;
SWIG_check_num_args("lldb::SBMemoryRegionInfoList::SBMemoryRegionInfoList",0,0)
result = (lldb::SBMemoryRegionInfoList *)new lldb::SBMemoryRegionInfoList();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBMemoryRegionInfoList__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfoList *arg1 = 0 ;
lldb::SBMemoryRegionInfoList *result = 0 ;
SWIG_check_num_args("lldb::SBMemoryRegionInfoList::SBMemoryRegionInfoList",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::SBMemoryRegionInfoList",1,"lldb::SBMemoryRegionInfoList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,0))){
SWIG_fail_ptr("new_SBMemoryRegionInfoList",1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList);
}
result = (lldb::SBMemoryRegionInfoList *)new lldb::SBMemoryRegionInfoList((lldb::SBMemoryRegionInfoList const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBMemoryRegionInfoList(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBMemoryRegionInfoList__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBMemoryRegionInfoList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBMemoryRegionInfoList__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBMemoryRegionInfoList'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBMemoryRegionInfoList::SBMemoryRegionInfoList()\n"
" lldb::SBMemoryRegionInfoList::SBMemoryRegionInfoList(lldb::SBMemoryRegionInfoList const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBMemoryRegionInfoList_GetSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBMemoryRegionInfoList::GetSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::GetSize",1,"lldb::SBMemoryRegionInfoList const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,0))){
SWIG_fail_ptr("SBMemoryRegionInfoList_GetSize",1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList);
}
result = (uint32_t)((lldb::SBMemoryRegionInfoList const *)arg1)->GetSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfoList_GetMemoryRegionContainingAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ;
lldb::addr_t arg2 ;
lldb::SBMemoryRegionInfo *arg3 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBMemoryRegionInfoList::GetMemoryRegionContainingAddress",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::GetMemoryRegionContainingAddress",1,"lldb::SBMemoryRegionInfoList *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::GetMemoryRegionContainingAddress",2,"lldb::addr_t");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::GetMemoryRegionContainingAddress",3,"lldb::SBMemoryRegionInfo &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,0))){
SWIG_fail_ptr("SBMemoryRegionInfoList_GetMemoryRegionContainingAddress",1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfoList_GetMemoryRegionContainingAddress",3,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
result = (bool)(arg1)->GetMemoryRegionContainingAddress(arg2,*arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfoList_GetMemoryRegionAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ;
uint32_t arg2 ;
lldb::SBMemoryRegionInfo *arg3 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBMemoryRegionInfoList::GetMemoryRegionAtIndex",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::GetMemoryRegionAtIndex",1,"lldb::SBMemoryRegionInfoList *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::GetMemoryRegionAtIndex",2,"uint32_t");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::GetMemoryRegionAtIndex",3,"lldb::SBMemoryRegionInfo &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,0))){
SWIG_fail_ptr("SBMemoryRegionInfoList_GetMemoryRegionAtIndex",1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfoList_GetMemoryRegionAtIndex",3,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
result = (bool)(arg1)->GetMemoryRegionAtIndex(arg2,*arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfoList_Append__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ;
lldb::SBMemoryRegionInfo *arg2 = 0 ;
SWIG_check_num_args("lldb::SBMemoryRegionInfoList::Append",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::Append",1,"lldb::SBMemoryRegionInfoList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::Append",2,"lldb::SBMemoryRegionInfo &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,0))){
SWIG_fail_ptr("SBMemoryRegionInfoList_Append",1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBMemoryRegionInfoList_Append",2,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
(arg1)->Append(*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfoList_Append__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ;
lldb::SBMemoryRegionInfoList *arg2 = 0 ;
SWIG_check_num_args("lldb::SBMemoryRegionInfoList::Append",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::Append",1,"lldb::SBMemoryRegionInfoList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::Append",2,"lldb::SBMemoryRegionInfoList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,0))){
SWIG_fail_ptr("SBMemoryRegionInfoList_Append",1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,0))){
SWIG_fail_ptr("SBMemoryRegionInfoList_Append",2,SWIGTYPE_p_lldb__SBMemoryRegionInfoList);
}
(arg1)->Append(*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBMemoryRegionInfoList_Append(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBMemoryRegionInfoList, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBMemoryRegionInfo, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBMemoryRegionInfoList_Append__SWIG_0(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBMemoryRegionInfoList, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBMemoryRegionInfoList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBMemoryRegionInfoList_Append__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBMemoryRegionInfoList_Append'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBMemoryRegionInfoList::Append(lldb::SBMemoryRegionInfo &)\n"
" lldb::SBMemoryRegionInfoList::Append(lldb::SBMemoryRegionInfoList &)\n");
lua_error(L);return 0;
}
static int _wrap_SBMemoryRegionInfoList_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ;
SWIG_check_num_args("lldb::SBMemoryRegionInfoList::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::Clear",1,"lldb::SBMemoryRegionInfoList *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,0))){
SWIG_fail_ptr("SBMemoryRegionInfoList_Clear",1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBMemoryRegionInfoList(void *obj) {
lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBMemoryRegionInfoList(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBMemoryRegionInfoList);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBMemoryRegionInfoList_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBMemoryRegionInfoList_methods[]= {
{ "GetSize", _wrap_SBMemoryRegionInfoList_GetSize},
{ "GetMemoryRegionContainingAddress", _wrap_SBMemoryRegionInfoList_GetMemoryRegionContainingAddress},
{ "GetMemoryRegionAtIndex", _wrap_SBMemoryRegionInfoList_GetMemoryRegionAtIndex},
{ "Append", _wrap_SBMemoryRegionInfoList_Append},
{ "Clear", _wrap_SBMemoryRegionInfoList_Clear},
{0,0}
};
static swig_lua_method swig_SBMemoryRegionInfoList_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBMemoryRegionInfoList_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBMemoryRegionInfoList_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBMemoryRegionInfoList_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBMemoryRegionInfoList_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBMemoryRegionInfoList_Sf_SwigStatic = {
"SBMemoryRegionInfoList",
swig_SBMemoryRegionInfoList_Sf_SwigStatic_methods,
swig_SBMemoryRegionInfoList_Sf_SwigStatic_attributes,
swig_SBMemoryRegionInfoList_Sf_SwigStatic_constants,
swig_SBMemoryRegionInfoList_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBMemoryRegionInfoList_bases[] = {0};
static const char *swig_SBMemoryRegionInfoList_base_names[] = {0};
static swig_lua_class _wrap_class_SBMemoryRegionInfoList = { "SBMemoryRegionInfoList", "SBMemoryRegionInfoList", &SWIGTYPE_p_lldb__SBMemoryRegionInfoList,_proxy__wrap_new_SBMemoryRegionInfoList, swig_delete_SBMemoryRegionInfoList, swig_SBMemoryRegionInfoList_methods, swig_SBMemoryRegionInfoList_attributes, &swig_SBMemoryRegionInfoList_Sf_SwigStatic, swig_SBMemoryRegionInfoList_meta, swig_SBMemoryRegionInfoList_bases, swig_SBMemoryRegionInfoList_base_names };
static int _wrap_new_SBModule__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *result = 0 ;
SWIG_check_num_args("lldb::SBModule::SBModule",0,0)
result = (lldb::SBModule *)new lldb::SBModule();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBModule__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = 0 ;
lldb::SBModule *result = 0 ;
SWIG_check_num_args("lldb::SBModule::SBModule",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBModule::SBModule",1,"lldb::SBModule const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("new_SBModule",1,SWIGTYPE_p_lldb__SBModule);
}
result = (lldb::SBModule *)new lldb::SBModule((lldb::SBModule const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBModule__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = 0 ;
lldb::SBModule *result = 0 ;
SWIG_check_num_args("lldb::SBModule::SBModule",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBModule::SBModule",1,"lldb::SBModuleSpec const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("new_SBModule",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
result = (lldb::SBModule *)new lldb::SBModule((lldb::SBModuleSpec const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBModule__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = 0 ;
lldb::addr_t arg2 ;
lldb::SBModule *result = 0 ;
SWIG_check_num_args("lldb::SBModule::SBModule",2,2)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBModule::SBModule",1,"lldb::SBProcess &");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModule::SBModule",2,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("new_SBModule",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
result = (lldb::SBModule *)new lldb::SBModule(*arg1,arg2);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBModule(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBModule__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBModule__SWIG_1(L);
}
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModuleSpec, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBModule__SWIG_2(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_new_SBModule__SWIG_3(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBModule'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBModule::SBModule()\n"
" lldb::SBModule::SBModule(lldb::SBModule const &)\n"
" lldb::SBModule::SBModule(lldb::SBModuleSpec const &)\n"
" lldb::SBModule::SBModule(lldb::SBProcess &,lldb::addr_t)\n");
lua_error(L);return 0;
}
static int _wrap_SBModule_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBModule::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::IsValid",1,"lldb::SBModule const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_IsValid",1,SWIGTYPE_p_lldb__SBModule);
}
result = (bool)((lldb::SBModule const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
SWIG_check_num_args("lldb::SBModule::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::Clear",1,"lldb::SBModule *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_Clear",1,SWIGTYPE_p_lldb__SBModule);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_IsFileBacked(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBModule::IsFileBacked",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::IsFileBacked",1,"lldb::SBModule const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_IsFileBacked",1,SWIGTYPE_p_lldb__SBModule);
}
result = (bool)((lldb::SBModule const *)arg1)->IsFileBacked();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetFileSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBModule::GetFileSpec",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetFileSpec",1,"lldb::SBModule const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetFileSpec",1,SWIGTYPE_p_lldb__SBModule);
}
result = ((lldb::SBModule const *)arg1)->GetFileSpec();
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetPlatformFileSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBModule::GetPlatformFileSpec",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetPlatformFileSpec",1,"lldb::SBModule const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetPlatformFileSpec",1,SWIGTYPE_p_lldb__SBModule);
}
result = ((lldb::SBModule const *)arg1)->GetPlatformFileSpec();
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_SetPlatformFileSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBModule::SetPlatformFileSpec",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::SetPlatformFileSpec",1,"lldb::SBModule *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModule::SetPlatformFileSpec",2,"lldb::SBFileSpec const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_SetPlatformFileSpec",1,SWIGTYPE_p_lldb__SBModule);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBModule_SetPlatformFileSpec",2,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (bool)(arg1)->SetPlatformFileSpec((lldb::SBFileSpec const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetRemoteInstallFileSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBModule::GetRemoteInstallFileSpec",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetRemoteInstallFileSpec",1,"lldb::SBModule *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetRemoteInstallFileSpec",1,SWIGTYPE_p_lldb__SBModule);
}
result = (arg1)->GetRemoteInstallFileSpec();
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_SetRemoteInstallFileSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBModule::SetRemoteInstallFileSpec",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::SetRemoteInstallFileSpec",1,"lldb::SBModule *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModule::SetRemoteInstallFileSpec",2,"lldb::SBFileSpec &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_SetRemoteInstallFileSpec",1,SWIGTYPE_p_lldb__SBModule);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBModule_SetRemoteInstallFileSpec",2,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (bool)(arg1)->SetRemoteInstallFileSpec(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetUUIDString(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBModule::GetUUIDString",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetUUIDString",1,"lldb::SBModule const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetUUIDString",1,SWIGTYPE_p_lldb__SBModule);
}
result = (char *)((lldb::SBModule const *)arg1)->GetUUIDString();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::SBModule *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBModule::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::operator ==",1,"lldb::SBModule const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModule::operator ==",2,"lldb::SBModule const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule___eq",1,SWIGTYPE_p_lldb__SBModule);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule___eq",2,SWIGTYPE_p_lldb__SBModule);
}
result = (bool)((lldb::SBModule const *)arg1)->operator ==((lldb::SBModule const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_FindSection(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBSection result;
SWIG_check_num_args("lldb::SBModule::FindSection",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindSection",1,"lldb::SBModule *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModule::FindSection",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_FindSection",1,SWIGTYPE_p_lldb__SBModule);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->FindSection((char const *)arg2);
{
lldb::SBSection * resultptr = new lldb::SBSection((const lldb::SBSection &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSection,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_ResolveFileAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::addr_t arg2 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBModule::ResolveFileAddress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::ResolveFileAddress",1,"lldb::SBModule *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModule::ResolveFileAddress",2,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_ResolveFileAddress",1,SWIGTYPE_p_lldb__SBModule);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
result = (arg1)->ResolveFileAddress(arg2);
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_ResolveSymbolContextForAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::SBAddress *arg2 = 0 ;
uint32_t arg3 ;
lldb::SBSymbolContext result;
SWIG_check_num_args("lldb::SBModule::ResolveSymbolContextForAddress",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::ResolveSymbolContextForAddress",1,"lldb::SBModule *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModule::ResolveSymbolContextForAddress",2,"lldb::SBAddress const &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBModule::ResolveSymbolContextForAddress",3,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_ResolveSymbolContextForAddress",1,SWIGTYPE_p_lldb__SBModule);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBModule_ResolveSymbolContextForAddress",2,SWIGTYPE_p_lldb__SBAddress);
}
arg3 = (uint32_t)lua_tointeger(L, 3);
result = (arg1)->ResolveSymbolContextForAddress((lldb::SBAddress const &)*arg2,arg3);
{
lldb::SBSymbolContext * resultptr = new lldb::SBSymbolContext((const lldb::SBSymbolContext &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContext,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBModule::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetDescription",1,"lldb::SBModule *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModule::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetDescription",1,SWIGTYPE_p_lldb__SBModule);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBModule_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetNumCompileUnits(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBModule::GetNumCompileUnits",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetNumCompileUnits",1,"lldb::SBModule *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetNumCompileUnits",1,SWIGTYPE_p_lldb__SBModule);
}
result = (uint32_t)(arg1)->GetNumCompileUnits();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetCompileUnitAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
uint32_t arg2 ;
lldb::SBCompileUnit result;
SWIG_check_num_args("lldb::SBModule::GetCompileUnitAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetCompileUnitAtIndex",1,"lldb::SBModule *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModule::GetCompileUnitAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetCompileUnitAtIndex",1,SWIGTYPE_p_lldb__SBModule);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetCompileUnitAtIndex(arg2);
{
lldb::SBCompileUnit * resultptr = new lldb::SBCompileUnit((const lldb::SBCompileUnit &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBCompileUnit,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_FindCompileUnits(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
lldb::SBSymbolContextList result;
SWIG_check_num_args("lldb::SBModule::FindCompileUnits",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindCompileUnits",1,"lldb::SBModule *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModule::FindCompileUnits",2,"lldb::SBFileSpec const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_FindCompileUnits",1,SWIGTYPE_p_lldb__SBModule);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBModule_FindCompileUnits",2,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (arg1)->FindCompileUnits((lldb::SBFileSpec const &)*arg2);
{
lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList((const lldb::SBSymbolContextList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetNumSymbols(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBModule::GetNumSymbols",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetNumSymbols",1,"lldb::SBModule *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetNumSymbols",1,SWIGTYPE_p_lldb__SBModule);
}
result = (arg1)->GetNumSymbols();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetSymbolAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
size_t arg2 ;
lldb::SBSymbol result;
SWIG_check_num_args("lldb::SBModule::GetSymbolAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetSymbolAtIndex",1,"lldb::SBModule *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModule::GetSymbolAtIndex",2,"size_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetSymbolAtIndex",1,SWIGTYPE_p_lldb__SBModule);
}
arg2 = (size_t)lua_tointeger(L, 2);
result = (arg1)->GetSymbolAtIndex(arg2);
{
lldb::SBSymbol * resultptr = new lldb::SBSymbol((const lldb::SBSymbol &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbol,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_FindSymbol__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SymbolType arg3 ;
lldb::SBSymbol result;
SWIG_check_num_args("lldb::SBModule::FindSymbol",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindSymbol",1,"lldb::SBModule *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModule::FindSymbol",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBModule::FindSymbol",3,"lldb::SymbolType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_FindSymbol",1,SWIGTYPE_p_lldb__SBModule);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (lldb::SymbolType)lua_tointeger(L, 3);
result = (arg1)->FindSymbol((char const *)arg2,arg3);
{
lldb::SBSymbol * resultptr = new lldb::SBSymbol((const lldb::SBSymbol &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbol,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_FindSymbol__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBSymbol result;
SWIG_check_num_args("lldb::SBModule::FindSymbol",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindSymbol",1,"lldb::SBModule *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModule::FindSymbol",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_FindSymbol",1,SWIGTYPE_p_lldb__SBModule);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->FindSymbol((char const *)arg2);
{
lldb::SBSymbol * resultptr = new lldb::SBSymbol((const lldb::SBSymbol &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbol,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_FindSymbol(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBModule_FindSymbol__SWIG_1(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBModule_FindSymbol__SWIG_0(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBModule_FindSymbol'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBModule::FindSymbol(char const *,lldb::SymbolType)\n"
" lldb::SBModule::FindSymbol(char const *)\n");
lua_error(L);return 0;
}
static int _wrap_SBModule_FindSymbols__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SymbolType arg3 ;
lldb::SBSymbolContextList result;
SWIG_check_num_args("lldb::SBModule::FindSymbols",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindSymbols",1,"lldb::SBModule *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModule::FindSymbols",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBModule::FindSymbols",3,"lldb::SymbolType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_FindSymbols",1,SWIGTYPE_p_lldb__SBModule);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (lldb::SymbolType)lua_tointeger(L, 3);
result = (arg1)->FindSymbols((char const *)arg2,arg3);
{
lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList((const lldb::SBSymbolContextList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_FindSymbols__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBSymbolContextList result;
SWIG_check_num_args("lldb::SBModule::FindSymbols",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindSymbols",1,"lldb::SBModule *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModule::FindSymbols",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_FindSymbols",1,SWIGTYPE_p_lldb__SBModule);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->FindSymbols((char const *)arg2);
{
lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList((const lldb::SBSymbolContextList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_FindSymbols(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBModule_FindSymbols__SWIG_1(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBModule_FindSymbols__SWIG_0(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBModule_FindSymbols'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBModule::FindSymbols(char const *,lldb::SymbolType)\n"
" lldb::SBModule::FindSymbols(char const *)\n");
lua_error(L);return 0;
}
static int _wrap_SBModule_GetNumSections(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBModule::GetNumSections",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetNumSections",1,"lldb::SBModule *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetNumSections",1,SWIGTYPE_p_lldb__SBModule);
}
result = (arg1)->GetNumSections();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetSectionAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
size_t arg2 ;
lldb::SBSection result;
SWIG_check_num_args("lldb::SBModule::GetSectionAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetSectionAtIndex",1,"lldb::SBModule *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModule::GetSectionAtIndex",2,"size_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetSectionAtIndex",1,SWIGTYPE_p_lldb__SBModule);
}
arg2 = (size_t)lua_tointeger(L, 2);
result = (arg1)->GetSectionAtIndex(arg2);
{
lldb::SBSection * resultptr = new lldb::SBSection((const lldb::SBSection &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSection,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_FindFunctions__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
char *arg2 = (char *) 0 ;
uint32_t arg3 ;
lldb::SBSymbolContextList result;
SWIG_check_num_args("lldb::SBModule::FindFunctions",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindFunctions",1,"lldb::SBModule *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModule::FindFunctions",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBModule::FindFunctions",3,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_FindFunctions",1,SWIGTYPE_p_lldb__SBModule);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
result = (arg1)->FindFunctions((char const *)arg2,arg3);
{
lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList((const lldb::SBSymbolContextList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_FindFunctions__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBSymbolContextList result;
SWIG_check_num_args("lldb::SBModule::FindFunctions",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindFunctions",1,"lldb::SBModule *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModule::FindFunctions",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_FindFunctions",1,SWIGTYPE_p_lldb__SBModule);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->FindFunctions((char const *)arg2);
{
lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList((const lldb::SBSymbolContextList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_FindFunctions(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBModule_FindFunctions__SWIG_1(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBModule_FindFunctions__SWIG_0(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBModule_FindFunctions'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBModule::FindFunctions(char const *,uint32_t)\n"
" lldb::SBModule::FindFunctions(char const *)\n");
lua_error(L);return 0;
}
static int _wrap_SBModule_FindFirstType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBModule::FindFirstType",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindFirstType",1,"lldb::SBModule *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModule::FindFirstType",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_FindFirstType",1,SWIGTYPE_p_lldb__SBModule);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->FindFirstType((char const *)arg2);
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_FindTypes(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBTypeList result;
SWIG_check_num_args("lldb::SBModule::FindTypes",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindTypes",1,"lldb::SBModule *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModule::FindTypes",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_FindTypes",1,SWIGTYPE_p_lldb__SBModule);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->FindTypes((char const *)arg2);
{
lldb::SBTypeList * resultptr = new lldb::SBTypeList((const lldb::SBTypeList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetTypeByID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::user_id_t arg2 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBModule::GetTypeByID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetTypeByID",1,"lldb::SBModule *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModule::GetTypeByID",2,"lldb::user_id_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetTypeByID",1,SWIGTYPE_p_lldb__SBModule);
}
arg2 = (lldb::user_id_t)lua_tointeger(L, 2);
result = (arg1)->GetTypeByID(arg2);
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetBasicType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::BasicType arg2 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBModule::GetBasicType",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetBasicType",1,"lldb::SBModule *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModule::GetBasicType",2,"lldb::BasicType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetBasicType",1,SWIGTYPE_p_lldb__SBModule);
}
arg2 = (lldb::BasicType)lua_tointeger(L, 2);
result = (arg1)->GetBasicType(arg2);
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetTypes__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
uint32_t arg2 ;
lldb::SBTypeList result;
SWIG_check_num_args("lldb::SBModule::GetTypes",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetTypes",1,"lldb::SBModule *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModule::GetTypes",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetTypes",1,SWIGTYPE_p_lldb__SBModule);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetTypes(arg2);
{
lldb::SBTypeList * resultptr = new lldb::SBTypeList((const lldb::SBTypeList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetTypes__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::SBTypeList result;
SWIG_check_num_args("lldb::SBModule::GetTypes",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetTypes",1,"lldb::SBModule *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetTypes",1,SWIGTYPE_p_lldb__SBModule);
}
result = (arg1)->GetTypes();
{
lldb::SBTypeList * resultptr = new lldb::SBTypeList((const lldb::SBTypeList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetTypes(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBModule_GetTypes__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBModule_GetTypes__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBModule_GetTypes'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBModule::GetTypes(uint32_t)\n"
" lldb::SBModule::GetTypes()\n");
lua_error(L);return 0;
}
static int _wrap_SBModule_FindGlobalVariables(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::SBTarget *arg2 = 0 ;
char *arg3 = (char *) 0 ;
uint32_t arg4 ;
lldb::SBValueList result;
SWIG_check_num_args("lldb::SBModule::FindGlobalVariables",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindGlobalVariables",1,"lldb::SBModule *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModule::FindGlobalVariables",2,"lldb::SBTarget &");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBModule::FindGlobalVariables",3,"char const *");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBModule::FindGlobalVariables",4,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_FindGlobalVariables",1,SWIGTYPE_p_lldb__SBModule);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBModule_FindGlobalVariables",2,SWIGTYPE_p_lldb__SBTarget);
}
arg3 = (char *)lua_tostring(L, 3);
arg4 = (uint32_t)lua_tointeger(L, 4);
result = (arg1)->FindGlobalVariables(*arg2,(char const *)arg3,arg4);
{
lldb::SBValueList * resultptr = new lldb::SBValueList((const lldb::SBValueList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_FindFirstGlobalVariable(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::SBTarget *arg2 = 0 ;
char *arg3 = (char *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBModule::FindFirstGlobalVariable",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindFirstGlobalVariable",1,"lldb::SBModule *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModule::FindFirstGlobalVariable",2,"lldb::SBTarget &");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBModule::FindFirstGlobalVariable",3,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_FindFirstGlobalVariable",1,SWIGTYPE_p_lldb__SBModule);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBModule_FindFirstGlobalVariable",2,SWIGTYPE_p_lldb__SBTarget);
}
arg3 = (char *)lua_tostring(L, 3);
result = (arg1)->FindFirstGlobalVariable(*arg2,(char const *)arg3);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetByteOrder(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::ByteOrder result;
SWIG_check_num_args("lldb::SBModule::GetByteOrder",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetByteOrder",1,"lldb::SBModule *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetByteOrder",1,SWIGTYPE_p_lldb__SBModule);
}
result = (lldb::ByteOrder)(arg1)->GetByteOrder();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetAddressByteSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBModule::GetAddressByteSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetAddressByteSize",1,"lldb::SBModule *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetAddressByteSize",1,SWIGTYPE_p_lldb__SBModule);
}
result = (uint32_t)(arg1)->GetAddressByteSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetTriple(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBModule::GetTriple",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetTriple",1,"lldb::SBModule *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetTriple",1,SWIGTYPE_p_lldb__SBModule);
}
result = (char *)(arg1)->GetTriple();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetVersion(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
uint32_t *arg2 = (uint32_t *) 0 ;
uint32_t arg3 ;
uint32_t result;
SWIG_check_num_args("lldb::SBModule::GetVersion",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetVersion",1,"lldb::SBModule *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetVersion",1,SWIGTYPE_p_lldb__SBModule);
}
{
arg3 = 99;
arg2 = (uint32_t *)malloc(sizeof(uint32_t) * arg3);
}
result = (uint32_t)(arg1)->GetVersion(arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
{
uint32_t count = result;
if (count >= arg3)
count = arg3;
lua_newtable(L);
int i = 0;
while (i++ < count) {
lua_pushinteger(L, arg2[i - 1]);
lua_seti(L, -2, i);
}
SWIG_arg++;
free(arg2);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetSymbolFileSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBModule::GetSymbolFileSpec",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetSymbolFileSpec",1,"lldb::SBModule const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetSymbolFileSpec",1,SWIGTYPE_p_lldb__SBModule);
}
result = ((lldb::SBModule const *)arg1)->GetSymbolFileSpec();
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetObjectFileHeaderAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBModule::GetObjectFileHeaderAddress",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetObjectFileHeaderAddress",1,"lldb::SBModule const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetObjectFileHeaderAddress",1,SWIGTYPE_p_lldb__SBModule);
}
result = ((lldb::SBModule const *)arg1)->GetObjectFileHeaderAddress();
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetObjectFileEntryPointAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBModule::GetObjectFileEntryPointAddress",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetObjectFileEntryPointAddress",1,"lldb::SBModule const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule_GetObjectFileEntryPointAddress",1,SWIGTYPE_p_lldb__SBModule);
}
result = ((lldb::SBModule const *)arg1)->GetObjectFileEntryPointAddress();
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GetNumberAllocatedModules(lua_State* L) {
int SWIG_arg = 0;
uint32_t result;
SWIG_check_num_args("lldb::SBModule::GetNumberAllocatedModules",0,0)
result = (uint32_t)lldb::SBModule::GetNumberAllocatedModules();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule_GarbageCollectAllocatedModules(lua_State* L) {
int SWIG_arg = 0;
SWIG_check_num_args("lldb::SBModule::GarbageCollectAllocatedModules",0,0)
lldb::SBModule::GarbageCollectAllocatedModules();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModule___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModule *arg1 = (lldb::SBModule *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBModule::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::__str__",1,"lldb::SBModule *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBModule___tostring",1,SWIGTYPE_p_lldb__SBModule);
}
result = lldb_SBModule___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBModule(void *obj) {
lldb::SBModule *arg1 = (lldb::SBModule *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBModule(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBModule);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBModule_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBModule_methods[]= {
{ "IsValid", _wrap_SBModule_IsValid},
{ "Clear", _wrap_SBModule_Clear},
{ "IsFileBacked", _wrap_SBModule_IsFileBacked},
{ "GetFileSpec", _wrap_SBModule_GetFileSpec},
{ "GetPlatformFileSpec", _wrap_SBModule_GetPlatformFileSpec},
{ "SetPlatformFileSpec", _wrap_SBModule_SetPlatformFileSpec},
{ "GetRemoteInstallFileSpec", _wrap_SBModule_GetRemoteInstallFileSpec},
{ "SetRemoteInstallFileSpec", _wrap_SBModule_SetRemoteInstallFileSpec},
{ "GetUUIDString", _wrap_SBModule_GetUUIDString},
{ "__eq", _wrap_SBModule___eq},
{ "FindSection", _wrap_SBModule_FindSection},
{ "ResolveFileAddress", _wrap_SBModule_ResolveFileAddress},
{ "ResolveSymbolContextForAddress", _wrap_SBModule_ResolveSymbolContextForAddress},
{ "GetDescription", _wrap_SBModule_GetDescription},
{ "GetNumCompileUnits", _wrap_SBModule_GetNumCompileUnits},
{ "GetCompileUnitAtIndex", _wrap_SBModule_GetCompileUnitAtIndex},
{ "FindCompileUnits", _wrap_SBModule_FindCompileUnits},
{ "GetNumSymbols", _wrap_SBModule_GetNumSymbols},
{ "GetSymbolAtIndex", _wrap_SBModule_GetSymbolAtIndex},
{ "FindSymbol", _wrap_SBModule_FindSymbol},
{ "FindSymbols", _wrap_SBModule_FindSymbols},
{ "GetNumSections", _wrap_SBModule_GetNumSections},
{ "GetSectionAtIndex", _wrap_SBModule_GetSectionAtIndex},
{ "FindFunctions", _wrap_SBModule_FindFunctions},
{ "FindFirstType", _wrap_SBModule_FindFirstType},
{ "FindTypes", _wrap_SBModule_FindTypes},
{ "GetTypeByID", _wrap_SBModule_GetTypeByID},
{ "GetBasicType", _wrap_SBModule_GetBasicType},
{ "GetTypes", _wrap_SBModule_GetTypes},
{ "FindGlobalVariables", _wrap_SBModule_FindGlobalVariables},
{ "FindFirstGlobalVariable", _wrap_SBModule_FindFirstGlobalVariable},
{ "GetByteOrder", _wrap_SBModule_GetByteOrder},
{ "GetAddressByteSize", _wrap_SBModule_GetAddressByteSize},
{ "GetTriple", _wrap_SBModule_GetTriple},
{ "GetVersion", _wrap_SBModule_GetVersion},
{ "GetSymbolFileSpec", _wrap_SBModule_GetSymbolFileSpec},
{ "GetObjectFileHeaderAddress", _wrap_SBModule_GetObjectFileHeaderAddress},
{ "GetObjectFileEntryPointAddress", _wrap_SBModule_GetObjectFileEntryPointAddress},
{ "__tostring", _wrap_SBModule___tostring},
{0,0}
};
static swig_lua_method swig_SBModule_meta[] = {
{ "__eq", _wrap_SBModule___eq},
{ "__tostring", _wrap_SBModule___tostring},
{0,0}
};
static swig_lua_attribute swig_SBModule_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBModule_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBModule_Sf_SwigStatic_methods[]= {
{ "GetNumberAllocatedModules", _wrap_SBModule_GetNumberAllocatedModules},
{ "GarbageCollectAllocatedModules", _wrap_SBModule_GarbageCollectAllocatedModules},
{0,0}
};
static swig_lua_class* swig_SBModule_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBModule_Sf_SwigStatic = {
"SBModule",
swig_SBModule_Sf_SwigStatic_methods,
swig_SBModule_Sf_SwigStatic_attributes,
swig_SBModule_Sf_SwigStatic_constants,
swig_SBModule_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBModule_bases[] = {0};
static const char *swig_SBModule_base_names[] = {0};
static swig_lua_class _wrap_class_SBModule = { "SBModule", "SBModule", &SWIGTYPE_p_lldb__SBModule,_proxy__wrap_new_SBModule, swig_delete_SBModule, swig_SBModule_methods, swig_SBModule_attributes, &swig_SBModule_Sf_SwigStatic, swig_SBModule_meta, swig_SBModule_bases, swig_SBModule_base_names };
static int _wrap_new_SBModuleSpec__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *result = 0 ;
SWIG_check_num_args("lldb::SBModuleSpec::SBModuleSpec",0,0)
result = (lldb::SBModuleSpec *)new lldb::SBModuleSpec();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBModuleSpec,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBModuleSpec__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = 0 ;
lldb::SBModuleSpec *result = 0 ;
SWIG_check_num_args("lldb::SBModuleSpec::SBModuleSpec",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::SBModuleSpec",1,"lldb::SBModuleSpec const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("new_SBModuleSpec",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
result = (lldb::SBModuleSpec *)new lldb::SBModuleSpec((lldb::SBModuleSpec const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBModuleSpec,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBModuleSpec(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBModuleSpec__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModuleSpec, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBModuleSpec__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBModuleSpec'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBModuleSpec::SBModuleSpec()\n"
" lldb::SBModuleSpec::SBModuleSpec(lldb::SBModuleSpec const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBModuleSpec_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBModuleSpec::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::IsValid",1,"lldb::SBModuleSpec const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpec_IsValid",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
result = (bool)((lldb::SBModuleSpec const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpec_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ;
SWIG_check_num_args("lldb::SBModuleSpec::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::Clear",1,"lldb::SBModuleSpec *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpec_Clear",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpec_GetFileSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBModuleSpec::GetFileSpec",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::GetFileSpec",1,"lldb::SBModuleSpec *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpec_GetFileSpec",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
result = (arg1)->GetFileSpec();
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpec_SetFileSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
SWIG_check_num_args("lldb::SBModuleSpec::SetFileSpec",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::SetFileSpec",1,"lldb::SBModuleSpec *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModuleSpec::SetFileSpec",2,"lldb::SBFileSpec const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpec_SetFileSpec",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBModuleSpec_SetFileSpec",2,SWIGTYPE_p_lldb__SBFileSpec);
}
(arg1)->SetFileSpec((lldb::SBFileSpec const &)*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpec_GetPlatformFileSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBModuleSpec::GetPlatformFileSpec",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::GetPlatformFileSpec",1,"lldb::SBModuleSpec *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpec_GetPlatformFileSpec",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
result = (arg1)->GetPlatformFileSpec();
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpec_SetPlatformFileSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
SWIG_check_num_args("lldb::SBModuleSpec::SetPlatformFileSpec",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::SetPlatformFileSpec",1,"lldb::SBModuleSpec *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModuleSpec::SetPlatformFileSpec",2,"lldb::SBFileSpec const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpec_SetPlatformFileSpec",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBModuleSpec_SetPlatformFileSpec",2,SWIGTYPE_p_lldb__SBFileSpec);
}
(arg1)->SetPlatformFileSpec((lldb::SBFileSpec const &)*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpec_GetSymbolFileSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBModuleSpec::GetSymbolFileSpec",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::GetSymbolFileSpec",1,"lldb::SBModuleSpec *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpec_GetSymbolFileSpec",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
result = (arg1)->GetSymbolFileSpec();
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpec_SetSymbolFileSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
SWIG_check_num_args("lldb::SBModuleSpec::SetSymbolFileSpec",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::SetSymbolFileSpec",1,"lldb::SBModuleSpec *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModuleSpec::SetSymbolFileSpec",2,"lldb::SBFileSpec const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpec_SetSymbolFileSpec",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBModuleSpec_SetSymbolFileSpec",2,SWIGTYPE_p_lldb__SBFileSpec);
}
(arg1)->SetSymbolFileSpec((lldb::SBFileSpec const &)*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpec_GetObjectName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBModuleSpec::GetObjectName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::GetObjectName",1,"lldb::SBModuleSpec *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpec_GetObjectName",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
result = (char *)(arg1)->GetObjectName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpec_SetObjectName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBModuleSpec::SetObjectName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::SetObjectName",1,"lldb::SBModuleSpec *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModuleSpec::SetObjectName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpec_SetObjectName",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetObjectName((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpec_GetTriple(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBModuleSpec::GetTriple",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::GetTriple",1,"lldb::SBModuleSpec *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpec_GetTriple",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
result = (char *)(arg1)->GetTriple();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpec_SetTriple(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBModuleSpec::SetTriple",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::SetTriple",1,"lldb::SBModuleSpec *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModuleSpec::SetTriple",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpec_SetTriple",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetTriple((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpec_GetUUIDBytes(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ;
uint8_t *result = 0 ;
SWIG_check_num_args("lldb::SBModuleSpec::GetUUIDBytes",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::GetUUIDBytes",1,"lldb::SBModuleSpec *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpec_GetUUIDBytes",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
result = (uint8_t *)(arg1)->GetUUIDBytes();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_char,0); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpec_GetUUIDLength(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBModuleSpec::GetUUIDLength",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::GetUUIDLength",1,"lldb::SBModuleSpec *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpec_GetUUIDLength",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
result = (arg1)->GetUUIDLength();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpec_SetUUIDBytes(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ;
uint8_t *arg2 = (uint8_t *) 0 ;
size_t arg3 ;
bool result;
SWIG_check_num_args("lldb::SBModuleSpec::SetUUIDBytes",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::SetUUIDBytes",1,"lldb::SBModuleSpec *");
if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBModuleSpec::SetUUIDBytes",2,"uint8_t const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBModuleSpec::SetUUIDBytes",3,"size_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpec_SetUUIDBytes",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){
SWIG_fail_ptr("SBModuleSpec_SetUUIDBytes",2,SWIGTYPE_p_unsigned_char);
}
arg3 = (size_t)lua_tointeger(L, 3);
result = (bool)(arg1)->SetUUIDBytes((uint8_t const *)arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpec_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBModuleSpec::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::GetDescription",1,"lldb::SBModuleSpec *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModuleSpec::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpec_GetDescription",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBModuleSpec_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpec___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBModuleSpec::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::__str__",1,"lldb::SBModuleSpec *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpec___tostring",1,SWIGTYPE_p_lldb__SBModuleSpec);
}
result = lldb_SBModuleSpec___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBModuleSpec(void *obj) {
lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBModuleSpec(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBModuleSpec);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBModuleSpec_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBModuleSpec_methods[]= {
{ "IsValid", _wrap_SBModuleSpec_IsValid},
{ "Clear", _wrap_SBModuleSpec_Clear},
{ "GetFileSpec", _wrap_SBModuleSpec_GetFileSpec},
{ "SetFileSpec", _wrap_SBModuleSpec_SetFileSpec},
{ "GetPlatformFileSpec", _wrap_SBModuleSpec_GetPlatformFileSpec},
{ "SetPlatformFileSpec", _wrap_SBModuleSpec_SetPlatformFileSpec},
{ "GetSymbolFileSpec", _wrap_SBModuleSpec_GetSymbolFileSpec},
{ "SetSymbolFileSpec", _wrap_SBModuleSpec_SetSymbolFileSpec},
{ "GetObjectName", _wrap_SBModuleSpec_GetObjectName},
{ "SetObjectName", _wrap_SBModuleSpec_SetObjectName},
{ "GetTriple", _wrap_SBModuleSpec_GetTriple},
{ "SetTriple", _wrap_SBModuleSpec_SetTriple},
{ "GetUUIDBytes", _wrap_SBModuleSpec_GetUUIDBytes},
{ "GetUUIDLength", _wrap_SBModuleSpec_GetUUIDLength},
{ "SetUUIDBytes", _wrap_SBModuleSpec_SetUUIDBytes},
{ "GetDescription", _wrap_SBModuleSpec_GetDescription},
{ "__tostring", _wrap_SBModuleSpec___tostring},
{0,0}
};
static swig_lua_method swig_SBModuleSpec_meta[] = {
{ "__tostring", _wrap_SBModuleSpec___tostring},
{0,0}
};
static swig_lua_attribute swig_SBModuleSpec_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBModuleSpec_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBModuleSpec_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBModuleSpec_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBModuleSpec_Sf_SwigStatic = {
"SBModuleSpec",
swig_SBModuleSpec_Sf_SwigStatic_methods,
swig_SBModuleSpec_Sf_SwigStatic_attributes,
swig_SBModuleSpec_Sf_SwigStatic_constants,
swig_SBModuleSpec_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBModuleSpec_bases[] = {0};
static const char *swig_SBModuleSpec_base_names[] = {0};
static swig_lua_class _wrap_class_SBModuleSpec = { "SBModuleSpec", "SBModuleSpec", &SWIGTYPE_p_lldb__SBModuleSpec,_proxy__wrap_new_SBModuleSpec, swig_delete_SBModuleSpec, swig_SBModuleSpec_methods, swig_SBModuleSpec_attributes, &swig_SBModuleSpec_Sf_SwigStatic, swig_SBModuleSpec_meta, swig_SBModuleSpec_bases, swig_SBModuleSpec_base_names };
static int _wrap_new_SBModuleSpecList__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpecList *result = 0 ;
SWIG_check_num_args("lldb::SBModuleSpecList::SBModuleSpecList",0,0)
result = (lldb::SBModuleSpecList *)new lldb::SBModuleSpecList();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBModuleSpecList,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBModuleSpecList__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpecList *arg1 = 0 ;
lldb::SBModuleSpecList *result = 0 ;
SWIG_check_num_args("lldb::SBModuleSpecList::SBModuleSpecList",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::SBModuleSpecList",1,"lldb::SBModuleSpecList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpecList,0))){
SWIG_fail_ptr("new_SBModuleSpecList",1,SWIGTYPE_p_lldb__SBModuleSpecList);
}
result = (lldb::SBModuleSpecList *)new lldb::SBModuleSpecList((lldb::SBModuleSpecList const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBModuleSpecList,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBModuleSpecList(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBModuleSpecList__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModuleSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBModuleSpecList__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBModuleSpecList'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBModuleSpecList::SBModuleSpecList()\n"
" lldb::SBModuleSpecList::SBModuleSpecList(lldb::SBModuleSpecList const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBModuleSpecList_GetModuleSpecifications(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
lldb::SBModuleSpecList result;
SWIG_check_num_args("lldb::SBModuleSpecList::GetModuleSpecifications",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::GetModuleSpecifications",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = lldb::SBModuleSpecList::GetModuleSpecifications((char const *)arg1);
{
lldb::SBModuleSpecList * resultptr = new lldb::SBModuleSpecList((const lldb::SBModuleSpecList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModuleSpecList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpecList_Append__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ;
lldb::SBModuleSpec *arg2 = 0 ;
SWIG_check_num_args("lldb::SBModuleSpecList::Append",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::Append",1,"lldb::SBModuleSpecList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModuleSpecList::Append",2,"lldb::SBModuleSpec const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpecList,0))){
SWIG_fail_ptr("SBModuleSpecList_Append",1,SWIGTYPE_p_lldb__SBModuleSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpecList_Append",2,SWIGTYPE_p_lldb__SBModuleSpec);
}
(arg1)->Append((lldb::SBModuleSpec const &)*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpecList_Append__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ;
lldb::SBModuleSpecList *arg2 = 0 ;
SWIG_check_num_args("lldb::SBModuleSpecList::Append",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::Append",1,"lldb::SBModuleSpecList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModuleSpecList::Append",2,"lldb::SBModuleSpecList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpecList,0))){
SWIG_fail_ptr("SBModuleSpecList_Append",1,SWIGTYPE_p_lldb__SBModuleSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBModuleSpecList,0))){
SWIG_fail_ptr("SBModuleSpecList_Append",2,SWIGTYPE_p_lldb__SBModuleSpecList);
}
(arg1)->Append((lldb::SBModuleSpecList const &)*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpecList_Append(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModuleSpecList, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBModuleSpec, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBModuleSpecList_Append__SWIG_0(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModuleSpecList, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBModuleSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBModuleSpecList_Append__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBModuleSpecList_Append'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBModuleSpecList::Append(lldb::SBModuleSpec const &)\n"
" lldb::SBModuleSpecList::Append(lldb::SBModuleSpecList const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBModuleSpecList_FindFirstMatchingSpec(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ;
lldb::SBModuleSpec *arg2 = 0 ;
lldb::SBModuleSpec result;
SWIG_check_num_args("lldb::SBModuleSpecList::FindFirstMatchingSpec",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::FindFirstMatchingSpec",1,"lldb::SBModuleSpecList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModuleSpecList::FindFirstMatchingSpec",2,"lldb::SBModuleSpec const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpecList,0))){
SWIG_fail_ptr("SBModuleSpecList_FindFirstMatchingSpec",1,SWIGTYPE_p_lldb__SBModuleSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpecList_FindFirstMatchingSpec",2,SWIGTYPE_p_lldb__SBModuleSpec);
}
result = (arg1)->FindFirstMatchingSpec((lldb::SBModuleSpec const &)*arg2);
{
lldb::SBModuleSpec * resultptr = new lldb::SBModuleSpec((const lldb::SBModuleSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModuleSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpecList_FindMatchingSpecs(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ;
lldb::SBModuleSpec *arg2 = 0 ;
lldb::SBModuleSpecList result;
SWIG_check_num_args("lldb::SBModuleSpecList::FindMatchingSpecs",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::FindMatchingSpecs",1,"lldb::SBModuleSpecList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModuleSpecList::FindMatchingSpecs",2,"lldb::SBModuleSpec const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpecList,0))){
SWIG_fail_ptr("SBModuleSpecList_FindMatchingSpecs",1,SWIGTYPE_p_lldb__SBModuleSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBModuleSpecList_FindMatchingSpecs",2,SWIGTYPE_p_lldb__SBModuleSpec);
}
result = (arg1)->FindMatchingSpecs((lldb::SBModuleSpec const &)*arg2);
{
lldb::SBModuleSpecList * resultptr = new lldb::SBModuleSpecList((const lldb::SBModuleSpecList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModuleSpecList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpecList_GetSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBModuleSpecList::GetSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::GetSize",1,"lldb::SBModuleSpecList *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpecList,0))){
SWIG_fail_ptr("SBModuleSpecList_GetSize",1,SWIGTYPE_p_lldb__SBModuleSpecList);
}
result = (arg1)->GetSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpecList_GetSpecAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ;
size_t arg2 ;
lldb::SBModuleSpec result;
SWIG_check_num_args("lldb::SBModuleSpecList::GetSpecAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::GetSpecAtIndex",1,"lldb::SBModuleSpecList *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModuleSpecList::GetSpecAtIndex",2,"size_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpecList,0))){
SWIG_fail_ptr("SBModuleSpecList_GetSpecAtIndex",1,SWIGTYPE_p_lldb__SBModuleSpecList);
}
arg2 = (size_t)lua_tointeger(L, 2);
result = (arg1)->GetSpecAtIndex(arg2);
{
lldb::SBModuleSpec * resultptr = new lldb::SBModuleSpec((const lldb::SBModuleSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModuleSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpecList_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBModuleSpecList::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::GetDescription",1,"lldb::SBModuleSpecList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModuleSpecList::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpecList,0))){
SWIG_fail_ptr("SBModuleSpecList_GetDescription",1,SWIGTYPE_p_lldb__SBModuleSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBModuleSpecList_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBModuleSpecList___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBModuleSpecList::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::__str__",1,"lldb::SBModuleSpecList *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpecList,0))){
SWIG_fail_ptr("SBModuleSpecList___tostring",1,SWIGTYPE_p_lldb__SBModuleSpecList);
}
result = lldb_SBModuleSpecList___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBModuleSpecList(void *obj) {
lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBModuleSpecList(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBModuleSpecList);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBModuleSpecList_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBModuleSpecList_methods[]= {
{ "Append", _wrap_SBModuleSpecList_Append},
{ "FindFirstMatchingSpec", _wrap_SBModuleSpecList_FindFirstMatchingSpec},
{ "FindMatchingSpecs", _wrap_SBModuleSpecList_FindMatchingSpecs},
{ "GetSize", _wrap_SBModuleSpecList_GetSize},
{ "GetSpecAtIndex", _wrap_SBModuleSpecList_GetSpecAtIndex},
{ "GetDescription", _wrap_SBModuleSpecList_GetDescription},
{ "__tostring", _wrap_SBModuleSpecList___tostring},
{0,0}
};
static swig_lua_method swig_SBModuleSpecList_meta[] = {
{ "__tostring", _wrap_SBModuleSpecList___tostring},
{0,0}
};
static swig_lua_attribute swig_SBModuleSpecList_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBModuleSpecList_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBModuleSpecList_Sf_SwigStatic_methods[]= {
{ "GetModuleSpecifications", _wrap_SBModuleSpecList_GetModuleSpecifications},
{0,0}
};
static swig_lua_class* swig_SBModuleSpecList_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBModuleSpecList_Sf_SwigStatic = {
"SBModuleSpecList",
swig_SBModuleSpecList_Sf_SwigStatic_methods,
swig_SBModuleSpecList_Sf_SwigStatic_attributes,
swig_SBModuleSpecList_Sf_SwigStatic_constants,
swig_SBModuleSpecList_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBModuleSpecList_bases[] = {0};
static const char *swig_SBModuleSpecList_base_names[] = {0};
static swig_lua_class _wrap_class_SBModuleSpecList = { "SBModuleSpecList", "SBModuleSpecList", &SWIGTYPE_p_lldb__SBModuleSpecList,_proxy__wrap_new_SBModuleSpecList, swig_delete_SBModuleSpecList, swig_SBModuleSpecList_methods, swig_SBModuleSpecList_attributes, &swig_SBModuleSpecList_Sf_SwigStatic, swig_SBModuleSpecList_meta, swig_SBModuleSpecList_bases, swig_SBModuleSpecList_base_names };
static int _wrap_new_SBPlatformConnectOptions__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
lldb::SBPlatformConnectOptions *result = 0 ;
SWIG_check_num_args("lldb::SBPlatformConnectOptions::SBPlatformConnectOptions",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::SBPlatformConnectOptions",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = (lldb::SBPlatformConnectOptions *)new lldb::SBPlatformConnectOptions((char const *)arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBPlatformConnectOptions,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBPlatformConnectOptions__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformConnectOptions *arg1 = 0 ;
lldb::SBPlatformConnectOptions *result = 0 ;
SWIG_check_num_args("lldb::SBPlatformConnectOptions::SBPlatformConnectOptions",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::SBPlatformConnectOptions",1,"lldb::SBPlatformConnectOptions const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformConnectOptions,0))){
SWIG_fail_ptr("new_SBPlatformConnectOptions",1,SWIGTYPE_p_lldb__SBPlatformConnectOptions);
}
result = (lldb::SBPlatformConnectOptions *)new lldb::SBPlatformConnectOptions((lldb::SBPlatformConnectOptions const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBPlatformConnectOptions,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBPlatformConnectOptions(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBPlatformConnectOptions, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBPlatformConnectOptions__SWIG_1(L);
}
}
if (argc == 1) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
return _wrap_new_SBPlatformConnectOptions__SWIG_0(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBPlatformConnectOptions'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBPlatformConnectOptions::SBPlatformConnectOptions(char const *)\n"
" lldb::SBPlatformConnectOptions::SBPlatformConnectOptions(lldb::SBPlatformConnectOptions const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBPlatformConnectOptions_GetURL(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBPlatformConnectOptions::GetURL",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::GetURL",1,"lldb::SBPlatformConnectOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformConnectOptions,0))){
SWIG_fail_ptr("SBPlatformConnectOptions_GetURL",1,SWIGTYPE_p_lldb__SBPlatformConnectOptions);
}
result = (char *)(arg1)->GetURL();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatformConnectOptions_SetURL(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBPlatformConnectOptions::SetURL",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::SetURL",1,"lldb::SBPlatformConnectOptions *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::SetURL",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformConnectOptions,0))){
SWIG_fail_ptr("SBPlatformConnectOptions_SetURL",1,SWIGTYPE_p_lldb__SBPlatformConnectOptions);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetURL((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatformConnectOptions_GetRsyncEnabled(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBPlatformConnectOptions::GetRsyncEnabled",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::GetRsyncEnabled",1,"lldb::SBPlatformConnectOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformConnectOptions,0))){
SWIG_fail_ptr("SBPlatformConnectOptions_GetRsyncEnabled",1,SWIGTYPE_p_lldb__SBPlatformConnectOptions);
}
result = (bool)(arg1)->GetRsyncEnabled();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatformConnectOptions_EnableRsync(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
bool arg4 ;
SWIG_check_num_args("lldb::SBPlatformConnectOptions::EnableRsync",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::EnableRsync",1,"lldb::SBPlatformConnectOptions *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::EnableRsync",2,"char const *");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::EnableRsync",3,"char const *");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::EnableRsync",4,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformConnectOptions,0))){
SWIG_fail_ptr("SBPlatformConnectOptions_EnableRsync",1,SWIGTYPE_p_lldb__SBPlatformConnectOptions);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (char *)lua_tostring(L, 3);
arg4 = (lua_toboolean(L, 4)!=0);
(arg1)->EnableRsync((char const *)arg2,(char const *)arg3,arg4);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatformConnectOptions_DisableRsync(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ;
SWIG_check_num_args("lldb::SBPlatformConnectOptions::DisableRsync",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::DisableRsync",1,"lldb::SBPlatformConnectOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformConnectOptions,0))){
SWIG_fail_ptr("SBPlatformConnectOptions_DisableRsync",1,SWIGTYPE_p_lldb__SBPlatformConnectOptions);
}
(arg1)->DisableRsync();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatformConnectOptions_GetLocalCacheDirectory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBPlatformConnectOptions::GetLocalCacheDirectory",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::GetLocalCacheDirectory",1,"lldb::SBPlatformConnectOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformConnectOptions,0))){
SWIG_fail_ptr("SBPlatformConnectOptions_GetLocalCacheDirectory",1,SWIGTYPE_p_lldb__SBPlatformConnectOptions);
}
result = (char *)(arg1)->GetLocalCacheDirectory();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatformConnectOptions_SetLocalCacheDirectory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBPlatformConnectOptions::SetLocalCacheDirectory",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::SetLocalCacheDirectory",1,"lldb::SBPlatformConnectOptions *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::SetLocalCacheDirectory",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformConnectOptions,0))){
SWIG_fail_ptr("SBPlatformConnectOptions_SetLocalCacheDirectory",1,SWIGTYPE_p_lldb__SBPlatformConnectOptions);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetLocalCacheDirectory((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBPlatformConnectOptions(void *obj) {
lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBPlatformConnectOptions(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBPlatformConnectOptions);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBPlatformConnectOptions_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBPlatformConnectOptions_methods[]= {
{ "GetURL", _wrap_SBPlatformConnectOptions_GetURL},
{ "SetURL", _wrap_SBPlatformConnectOptions_SetURL},
{ "GetRsyncEnabled", _wrap_SBPlatformConnectOptions_GetRsyncEnabled},
{ "EnableRsync", _wrap_SBPlatformConnectOptions_EnableRsync},
{ "DisableRsync", _wrap_SBPlatformConnectOptions_DisableRsync},
{ "GetLocalCacheDirectory", _wrap_SBPlatformConnectOptions_GetLocalCacheDirectory},
{ "SetLocalCacheDirectory", _wrap_SBPlatformConnectOptions_SetLocalCacheDirectory},
{0,0}
};
static swig_lua_method swig_SBPlatformConnectOptions_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBPlatformConnectOptions_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBPlatformConnectOptions_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBPlatformConnectOptions_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBPlatformConnectOptions_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBPlatformConnectOptions_Sf_SwigStatic = {
"SBPlatformConnectOptions",
swig_SBPlatformConnectOptions_Sf_SwigStatic_methods,
swig_SBPlatformConnectOptions_Sf_SwigStatic_attributes,
swig_SBPlatformConnectOptions_Sf_SwigStatic_constants,
swig_SBPlatformConnectOptions_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBPlatformConnectOptions_bases[] = {0};
static const char *swig_SBPlatformConnectOptions_base_names[] = {0};
static swig_lua_class _wrap_class_SBPlatformConnectOptions = { "SBPlatformConnectOptions", "SBPlatformConnectOptions", &SWIGTYPE_p_lldb__SBPlatformConnectOptions,_proxy__wrap_new_SBPlatformConnectOptions, swig_delete_SBPlatformConnectOptions, swig_SBPlatformConnectOptions_methods, swig_SBPlatformConnectOptions_attributes, &swig_SBPlatformConnectOptions_Sf_SwigStatic, swig_SBPlatformConnectOptions_meta, swig_SBPlatformConnectOptions_bases, swig_SBPlatformConnectOptions_base_names };
static int _wrap_new_SBPlatformShellCommand__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBPlatformShellCommand *result = 0 ;
SWIG_check_num_args("lldb::SBPlatformShellCommand::SBPlatformShellCommand",2,2)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SBPlatformShellCommand",1,"char const *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SBPlatformShellCommand",2,"char const *");
arg1 = (char *)lua_tostring(L, 1);
arg2 = (char *)lua_tostring(L, 2);
result = (lldb::SBPlatformShellCommand *)new lldb::SBPlatformShellCommand((char const *)arg1,(char const *)arg2);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBPlatformShellCommand,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBPlatformShellCommand__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
lldb::SBPlatformShellCommand *result = 0 ;
SWIG_check_num_args("lldb::SBPlatformShellCommand::SBPlatformShellCommand",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SBPlatformShellCommand",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = (lldb::SBPlatformShellCommand *)new lldb::SBPlatformShellCommand((char const *)arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBPlatformShellCommand,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBPlatformShellCommand__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformShellCommand *arg1 = 0 ;
lldb::SBPlatformShellCommand *result = 0 ;
SWIG_check_num_args("lldb::SBPlatformShellCommand::SBPlatformShellCommand",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SBPlatformShellCommand",1,"lldb::SBPlatformShellCommand const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){
SWIG_fail_ptr("new_SBPlatformShellCommand",1,SWIGTYPE_p_lldb__SBPlatformShellCommand);
}
result = (lldb::SBPlatformShellCommand *)new lldb::SBPlatformShellCommand((lldb::SBPlatformShellCommand const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBPlatformShellCommand,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBPlatformShellCommand(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBPlatformShellCommand, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBPlatformShellCommand__SWIG_2(L);
}
}
if (argc == 1) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
return _wrap_new_SBPlatformShellCommand__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_new_SBPlatformShellCommand__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBPlatformShellCommand'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBPlatformShellCommand::SBPlatformShellCommand(char const *,char const *)\n"
" lldb::SBPlatformShellCommand::SBPlatformShellCommand(char const *)\n"
" lldb::SBPlatformShellCommand::SBPlatformShellCommand(lldb::SBPlatformShellCommand const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBPlatformShellCommand_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ;
SWIG_check_num_args("lldb::SBPlatformShellCommand::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::Clear",1,"lldb::SBPlatformShellCommand *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){
SWIG_fail_ptr("SBPlatformShellCommand_Clear",1,SWIGTYPE_p_lldb__SBPlatformShellCommand);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatformShellCommand_GetShell(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBPlatformShellCommand::GetShell",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::GetShell",1,"lldb::SBPlatformShellCommand *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){
SWIG_fail_ptr("SBPlatformShellCommand_GetShell",1,SWIGTYPE_p_lldb__SBPlatformShellCommand);
}
result = (char *)(arg1)->GetShell();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatformShellCommand_SetShell(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBPlatformShellCommand::SetShell",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SetShell",1,"lldb::SBPlatformShellCommand *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SetShell",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){
SWIG_fail_ptr("SBPlatformShellCommand_SetShell",1,SWIGTYPE_p_lldb__SBPlatformShellCommand);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetShell((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatformShellCommand_GetCommand(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBPlatformShellCommand::GetCommand",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::GetCommand",1,"lldb::SBPlatformShellCommand *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){
SWIG_fail_ptr("SBPlatformShellCommand_GetCommand",1,SWIGTYPE_p_lldb__SBPlatformShellCommand);
}
result = (char *)(arg1)->GetCommand();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatformShellCommand_SetCommand(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBPlatformShellCommand::SetCommand",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SetCommand",1,"lldb::SBPlatformShellCommand *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SetCommand",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){
SWIG_fail_ptr("SBPlatformShellCommand_SetCommand",1,SWIGTYPE_p_lldb__SBPlatformShellCommand);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetCommand((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatformShellCommand_GetWorkingDirectory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBPlatformShellCommand::GetWorkingDirectory",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::GetWorkingDirectory",1,"lldb::SBPlatformShellCommand *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){
SWIG_fail_ptr("SBPlatformShellCommand_GetWorkingDirectory",1,SWIGTYPE_p_lldb__SBPlatformShellCommand);
}
result = (char *)(arg1)->GetWorkingDirectory();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatformShellCommand_SetWorkingDirectory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBPlatformShellCommand::SetWorkingDirectory",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SetWorkingDirectory",1,"lldb::SBPlatformShellCommand *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SetWorkingDirectory",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){
SWIG_fail_ptr("SBPlatformShellCommand_SetWorkingDirectory",1,SWIGTYPE_p_lldb__SBPlatformShellCommand);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetWorkingDirectory((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatformShellCommand_GetTimeoutSeconds(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBPlatformShellCommand::GetTimeoutSeconds",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::GetTimeoutSeconds",1,"lldb::SBPlatformShellCommand *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){
SWIG_fail_ptr("SBPlatformShellCommand_GetTimeoutSeconds",1,SWIGTYPE_p_lldb__SBPlatformShellCommand);
}
result = (uint32_t)(arg1)->GetTimeoutSeconds();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatformShellCommand_SetTimeoutSeconds(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBPlatformShellCommand::SetTimeoutSeconds",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SetTimeoutSeconds",1,"lldb::SBPlatformShellCommand *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SetTimeoutSeconds",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){
SWIG_fail_ptr("SBPlatformShellCommand_SetTimeoutSeconds",1,SWIGTYPE_p_lldb__SBPlatformShellCommand);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetTimeoutSeconds(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatformShellCommand_GetSignal(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ;
int result;
SWIG_check_num_args("lldb::SBPlatformShellCommand::GetSignal",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::GetSignal",1,"lldb::SBPlatformShellCommand *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){
SWIG_fail_ptr("SBPlatformShellCommand_GetSignal",1,SWIGTYPE_p_lldb__SBPlatformShellCommand);
}
result = (int)(arg1)->GetSignal();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatformShellCommand_GetStatus(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ;
int result;
SWIG_check_num_args("lldb::SBPlatformShellCommand::GetStatus",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::GetStatus",1,"lldb::SBPlatformShellCommand *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){
SWIG_fail_ptr("SBPlatformShellCommand_GetStatus",1,SWIGTYPE_p_lldb__SBPlatformShellCommand);
}
result = (int)(arg1)->GetStatus();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatformShellCommand_GetOutput(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBPlatformShellCommand::GetOutput",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::GetOutput",1,"lldb::SBPlatformShellCommand *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){
SWIG_fail_ptr("SBPlatformShellCommand_GetOutput",1,SWIGTYPE_p_lldb__SBPlatformShellCommand);
}
result = (char *)(arg1)->GetOutput();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBPlatformShellCommand(void *obj) {
lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBPlatformShellCommand(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBPlatformShellCommand);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBPlatformShellCommand_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBPlatformShellCommand_methods[]= {
{ "Clear", _wrap_SBPlatformShellCommand_Clear},
{ "GetShell", _wrap_SBPlatformShellCommand_GetShell},
{ "SetShell", _wrap_SBPlatformShellCommand_SetShell},
{ "GetCommand", _wrap_SBPlatformShellCommand_GetCommand},
{ "SetCommand", _wrap_SBPlatformShellCommand_SetCommand},
{ "GetWorkingDirectory", _wrap_SBPlatformShellCommand_GetWorkingDirectory},
{ "SetWorkingDirectory", _wrap_SBPlatformShellCommand_SetWorkingDirectory},
{ "GetTimeoutSeconds", _wrap_SBPlatformShellCommand_GetTimeoutSeconds},
{ "SetTimeoutSeconds", _wrap_SBPlatformShellCommand_SetTimeoutSeconds},
{ "GetSignal", _wrap_SBPlatformShellCommand_GetSignal},
{ "GetStatus", _wrap_SBPlatformShellCommand_GetStatus},
{ "GetOutput", _wrap_SBPlatformShellCommand_GetOutput},
{0,0}
};
static swig_lua_method swig_SBPlatformShellCommand_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBPlatformShellCommand_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBPlatformShellCommand_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBPlatformShellCommand_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBPlatformShellCommand_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBPlatformShellCommand_Sf_SwigStatic = {
"SBPlatformShellCommand",
swig_SBPlatformShellCommand_Sf_SwigStatic_methods,
swig_SBPlatformShellCommand_Sf_SwigStatic_attributes,
swig_SBPlatformShellCommand_Sf_SwigStatic_constants,
swig_SBPlatformShellCommand_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBPlatformShellCommand_bases[] = {0};
static const char *swig_SBPlatformShellCommand_base_names[] = {0};
static swig_lua_class _wrap_class_SBPlatformShellCommand = { "SBPlatformShellCommand", "SBPlatformShellCommand", &SWIGTYPE_p_lldb__SBPlatformShellCommand,_proxy__wrap_new_SBPlatformShellCommand, swig_delete_SBPlatformShellCommand, swig_SBPlatformShellCommand_methods, swig_SBPlatformShellCommand_attributes, &swig_SBPlatformShellCommand_Sf_SwigStatic, swig_SBPlatformShellCommand_meta, swig_SBPlatformShellCommand_bases, swig_SBPlatformShellCommand_base_names };
static int _wrap_new_SBPlatform__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *result = 0 ;
SWIG_check_num_args("lldb::SBPlatform::SBPlatform",0,0)
result = (lldb::SBPlatform *)new lldb::SBPlatform();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBPlatform,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBPlatform__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
lldb::SBPlatform *result = 0 ;
SWIG_check_num_args("lldb::SBPlatform::SBPlatform",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBPlatform::SBPlatform",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = (lldb::SBPlatform *)new lldb::SBPlatform((char const *)arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBPlatform,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBPlatform(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBPlatform__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
return _wrap_new_SBPlatform__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBPlatform'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBPlatform::SBPlatform()\n"
" lldb::SBPlatform::SBPlatform(char const *)\n");
lua_error(L);return 0;
}
static int _wrap_SBPlatform_GetHostPlatform(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform result;
SWIG_check_num_args("lldb::SBPlatform::GetHostPlatform",0,0)
result = lldb::SBPlatform::GetHostPlatform();
{
lldb::SBPlatform * resultptr = new lldb::SBPlatform((const lldb::SBPlatform &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBPlatform,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBPlatform::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::IsValid",1,"lldb::SBPlatform const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_IsValid",1,SWIGTYPE_p_lldb__SBPlatform);
}
result = (bool)((lldb::SBPlatform const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
SWIG_check_num_args("lldb::SBPlatform::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::Clear",1,"lldb::SBPlatform *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_Clear",1,SWIGTYPE_p_lldb__SBPlatform);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_GetWorkingDirectory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBPlatform::GetWorkingDirectory",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetWorkingDirectory",1,"lldb::SBPlatform *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_GetWorkingDirectory",1,SWIGTYPE_p_lldb__SBPlatform);
}
result = (char *)(arg1)->GetWorkingDirectory();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_SetWorkingDirectory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
char *arg2 = (char *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBPlatform::SetWorkingDirectory",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::SetWorkingDirectory",1,"lldb::SBPlatform *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatform::SetWorkingDirectory",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_SetWorkingDirectory",1,SWIGTYPE_p_lldb__SBPlatform);
}
arg2 = (char *)lua_tostring(L, 2);
result = (bool)(arg1)->SetWorkingDirectory((char const *)arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_GetName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBPlatform::GetName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetName",1,"lldb::SBPlatform *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_GetName",1,SWIGTYPE_p_lldb__SBPlatform);
}
result = (char *)(arg1)->GetName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_ConnectRemote(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
lldb::SBPlatformConnectOptions *arg2 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBPlatform::ConnectRemote",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::ConnectRemote",1,"lldb::SBPlatform *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBPlatform::ConnectRemote",2,"lldb::SBPlatformConnectOptions &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_ConnectRemote",1,SWIGTYPE_p_lldb__SBPlatform);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBPlatformConnectOptions,0))){
SWIG_fail_ptr("SBPlatform_ConnectRemote",2,SWIGTYPE_p_lldb__SBPlatformConnectOptions);
}
result = (arg1)->ConnectRemote(*arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_DisconnectRemote(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
SWIG_check_num_args("lldb::SBPlatform::DisconnectRemote",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::DisconnectRemote",1,"lldb::SBPlatform *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_DisconnectRemote",1,SWIGTYPE_p_lldb__SBPlatform);
}
(arg1)->DisconnectRemote();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_IsConnected(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBPlatform::IsConnected",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::IsConnected",1,"lldb::SBPlatform *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_IsConnected",1,SWIGTYPE_p_lldb__SBPlatform);
}
result = (bool)(arg1)->IsConnected();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_GetTriple(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBPlatform::GetTriple",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetTriple",1,"lldb::SBPlatform *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_GetTriple",1,SWIGTYPE_p_lldb__SBPlatform);
}
result = (char *)(arg1)->GetTriple();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_GetHostname(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBPlatform::GetHostname",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetHostname",1,"lldb::SBPlatform *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_GetHostname",1,SWIGTYPE_p_lldb__SBPlatform);
}
result = (char *)(arg1)->GetHostname();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_GetOSBuild(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBPlatform::GetOSBuild",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetOSBuild",1,"lldb::SBPlatform *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_GetOSBuild",1,SWIGTYPE_p_lldb__SBPlatform);
}
result = (char *)(arg1)->GetOSBuild();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_GetOSDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBPlatform::GetOSDescription",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetOSDescription",1,"lldb::SBPlatform *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_GetOSDescription",1,SWIGTYPE_p_lldb__SBPlatform);
}
result = (char *)(arg1)->GetOSDescription();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_GetOSMajorVersion(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBPlatform::GetOSMajorVersion",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetOSMajorVersion",1,"lldb::SBPlatform *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_GetOSMajorVersion",1,SWIGTYPE_p_lldb__SBPlatform);
}
result = (uint32_t)(arg1)->GetOSMajorVersion();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_GetOSMinorVersion(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBPlatform::GetOSMinorVersion",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetOSMinorVersion",1,"lldb::SBPlatform *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_GetOSMinorVersion",1,SWIGTYPE_p_lldb__SBPlatform);
}
result = (uint32_t)(arg1)->GetOSMinorVersion();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_GetOSUpdateVersion(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBPlatform::GetOSUpdateVersion",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetOSUpdateVersion",1,"lldb::SBPlatform *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_GetOSUpdateVersion",1,SWIGTYPE_p_lldb__SBPlatform);
}
result = (uint32_t)(arg1)->GetOSUpdateVersion();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_SetSDKRoot(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBPlatform::SetSDKRoot",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::SetSDKRoot",1,"lldb::SBPlatform *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatform::SetSDKRoot",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_SetSDKRoot",1,SWIGTYPE_p_lldb__SBPlatform);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetSDKRoot((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_Get(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
lldb::SBFileSpec *arg3 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBPlatform::Get",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::Get",1,"lldb::SBPlatform *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBPlatform::Get",2,"lldb::SBFileSpec &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBPlatform::Get",3,"lldb::SBFileSpec &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_Get",1,SWIGTYPE_p_lldb__SBPlatform);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBPlatform_Get",2,SWIGTYPE_p_lldb__SBFileSpec);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBPlatform_Get",3,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (arg1)->Get(*arg2,*arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_Put(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
lldb::SBFileSpec *arg3 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBPlatform::Put",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::Put",1,"lldb::SBPlatform *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBPlatform::Put",2,"lldb::SBFileSpec &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBPlatform::Put",3,"lldb::SBFileSpec &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_Put",1,SWIGTYPE_p_lldb__SBPlatform);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBPlatform_Put",2,SWIGTYPE_p_lldb__SBFileSpec);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBPlatform_Put",3,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (arg1)->Put(*arg2,*arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_Install(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
lldb::SBFileSpec *arg3 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBPlatform::Install",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::Install",1,"lldb::SBPlatform *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBPlatform::Install",2,"lldb::SBFileSpec &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBPlatform::Install",3,"lldb::SBFileSpec &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_Install",1,SWIGTYPE_p_lldb__SBPlatform);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBPlatform_Install",2,SWIGTYPE_p_lldb__SBFileSpec);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBPlatform_Install",3,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (arg1)->Install(*arg2,*arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_Run(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
lldb::SBPlatformShellCommand *arg2 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBPlatform::Run",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::Run",1,"lldb::SBPlatform *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBPlatform::Run",2,"lldb::SBPlatformShellCommand &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_Run",1,SWIGTYPE_p_lldb__SBPlatform);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){
SWIG_fail_ptr("SBPlatform_Run",2,SWIGTYPE_p_lldb__SBPlatformShellCommand);
}
result = (arg1)->Run(*arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_Launch(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
lldb::SBLaunchInfo *arg2 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBPlatform::Launch",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::Launch",1,"lldb::SBPlatform *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBPlatform::Launch",2,"lldb::SBLaunchInfo &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_Launch",1,SWIGTYPE_p_lldb__SBPlatform);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBPlatform_Launch",2,SWIGTYPE_p_lldb__SBLaunchInfo);
}
result = (arg1)->Launch(*arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_Kill(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
lldb::pid_t arg2 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBPlatform::Kill",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::Kill",1,"lldb::SBPlatform *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBPlatform::Kill",2,"lldb::pid_t const");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_Kill",1,SWIGTYPE_p_lldb__SBPlatform);
}
arg2 = (lldb::pid_t const)lua_tointeger(L, 2);
result = (arg1)->Kill(arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_MakeDirectory__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
char *arg2 = (char *) 0 ;
uint32_t arg3 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBPlatform::MakeDirectory",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::MakeDirectory",1,"lldb::SBPlatform *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatform::MakeDirectory",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBPlatform::MakeDirectory",3,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_MakeDirectory",1,SWIGTYPE_p_lldb__SBPlatform);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
result = (arg1)->MakeDirectory((char const *)arg2,arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_MakeDirectory__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBPlatform::MakeDirectory",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::MakeDirectory",1,"lldb::SBPlatform *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatform::MakeDirectory",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_MakeDirectory",1,SWIGTYPE_p_lldb__SBPlatform);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->MakeDirectory((char const *)arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_MakeDirectory(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBPlatform, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBPlatform_MakeDirectory__SWIG_1(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBPlatform, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBPlatform_MakeDirectory__SWIG_0(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBPlatform_MakeDirectory'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBPlatform::MakeDirectory(char const *,uint32_t)\n"
" lldb::SBPlatform::MakeDirectory(char const *)\n");
lua_error(L);return 0;
}
static int _wrap_SBPlatform_GetFilePermissions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
char *arg2 = (char *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBPlatform::GetFilePermissions",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetFilePermissions",1,"lldb::SBPlatform *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatform::GetFilePermissions",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_GetFilePermissions",1,SWIGTYPE_p_lldb__SBPlatform);
}
arg2 = (char *)lua_tostring(L, 2);
result = (uint32_t)(arg1)->GetFilePermissions((char const *)arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_SetFilePermissions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
char *arg2 = (char *) 0 ;
uint32_t arg3 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBPlatform::SetFilePermissions",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::SetFilePermissions",1,"lldb::SBPlatform *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatform::SetFilePermissions",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBPlatform::SetFilePermissions",3,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_SetFilePermissions",1,SWIGTYPE_p_lldb__SBPlatform);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
result = (arg1)->SetFilePermissions((char const *)arg2,arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_GetUnixSignals(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
lldb::SBUnixSignals result;
SWIG_check_num_args("lldb::SBPlatform::GetUnixSignals",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetUnixSignals",1,"lldb::SBPlatform *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_GetUnixSignals",1,SWIGTYPE_p_lldb__SBPlatform);
}
result = (arg1)->GetUnixSignals();
{
lldb::SBUnixSignals * resultptr = new lldb::SBUnixSignals((const lldb::SBUnixSignals &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBUnixSignals,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBPlatform_GetEnvironment(lua_State* L) {
int SWIG_arg = 0;
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ;
lldb::SBEnvironment result;
SWIG_check_num_args("lldb::SBPlatform::GetEnvironment",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetEnvironment",1,"lldb::SBPlatform *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){
SWIG_fail_ptr("SBPlatform_GetEnvironment",1,SWIGTYPE_p_lldb__SBPlatform);
}
result = (arg1)->GetEnvironment();
{
lldb::SBEnvironment * resultptr = new lldb::SBEnvironment((const lldb::SBEnvironment &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBEnvironment,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBPlatform(void *obj) {
lldb::SBPlatform *arg1 = (lldb::SBPlatform *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBPlatform(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBPlatform);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBPlatform_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBPlatform_methods[]= {
{ "IsValid", _wrap_SBPlatform_IsValid},
{ "Clear", _wrap_SBPlatform_Clear},
{ "GetWorkingDirectory", _wrap_SBPlatform_GetWorkingDirectory},
{ "SetWorkingDirectory", _wrap_SBPlatform_SetWorkingDirectory},
{ "GetName", _wrap_SBPlatform_GetName},
{ "ConnectRemote", _wrap_SBPlatform_ConnectRemote},
{ "DisconnectRemote", _wrap_SBPlatform_DisconnectRemote},
{ "IsConnected", _wrap_SBPlatform_IsConnected},
{ "GetTriple", _wrap_SBPlatform_GetTriple},
{ "GetHostname", _wrap_SBPlatform_GetHostname},
{ "GetOSBuild", _wrap_SBPlatform_GetOSBuild},
{ "GetOSDescription", _wrap_SBPlatform_GetOSDescription},
{ "GetOSMajorVersion", _wrap_SBPlatform_GetOSMajorVersion},
{ "GetOSMinorVersion", _wrap_SBPlatform_GetOSMinorVersion},
{ "GetOSUpdateVersion", _wrap_SBPlatform_GetOSUpdateVersion},
{ "SetSDKRoot", _wrap_SBPlatform_SetSDKRoot},
{ "Get", _wrap_SBPlatform_Get},
{ "Put", _wrap_SBPlatform_Put},
{ "Install", _wrap_SBPlatform_Install},
{ "Run", _wrap_SBPlatform_Run},
{ "Launch", _wrap_SBPlatform_Launch},
{ "Kill", _wrap_SBPlatform_Kill},
{ "MakeDirectory", _wrap_SBPlatform_MakeDirectory},
{ "GetFilePermissions", _wrap_SBPlatform_GetFilePermissions},
{ "SetFilePermissions", _wrap_SBPlatform_SetFilePermissions},
{ "GetUnixSignals", _wrap_SBPlatform_GetUnixSignals},
{ "GetEnvironment", _wrap_SBPlatform_GetEnvironment},
{0,0}
};
static swig_lua_method swig_SBPlatform_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBPlatform_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBPlatform_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBPlatform_Sf_SwigStatic_methods[]= {
{ "GetHostPlatform", _wrap_SBPlatform_GetHostPlatform},
{0,0}
};
static swig_lua_class* swig_SBPlatform_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBPlatform_Sf_SwigStatic = {
"SBPlatform",
swig_SBPlatform_Sf_SwigStatic_methods,
swig_SBPlatform_Sf_SwigStatic_attributes,
swig_SBPlatform_Sf_SwigStatic_constants,
swig_SBPlatform_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBPlatform_bases[] = {0};
static const char *swig_SBPlatform_base_names[] = {0};
static swig_lua_class _wrap_class_SBPlatform = { "SBPlatform", "SBPlatform", &SWIGTYPE_p_lldb__SBPlatform,_proxy__wrap_new_SBPlatform, swig_delete_SBPlatform, swig_SBPlatform_methods, swig_SBPlatform_attributes, &swig_SBPlatform_Sf_SwigStatic, swig_SBPlatform_meta, swig_SBPlatform_bases, swig_SBPlatform_base_names };
static int _wrap_new_SBProcess__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *result = 0 ;
SWIG_check_num_args("lldb::SBProcess::SBProcess",0,0)
result = (lldb::SBProcess *)new lldb::SBProcess();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBProcess__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = 0 ;
lldb::SBProcess *result = 0 ;
SWIG_check_num_args("lldb::SBProcess::SBProcess",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::SBProcess",1,"lldb::SBProcess const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("new_SBProcess",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (lldb::SBProcess *)new lldb::SBProcess((lldb::SBProcess const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBProcess(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBProcess__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBProcess__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBProcess'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBProcess::SBProcess()\n"
" lldb::SBProcess::SBProcess(lldb::SBProcess const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBProcess_GetBroadcasterClassName(lua_State* L) {
int SWIG_arg = 0;
char *result = 0 ;
SWIG_check_num_args("lldb::SBProcess::GetBroadcasterClassName",0,0)
result = (char *)lldb::SBProcess::GetBroadcasterClassName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetPluginName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBProcess::GetPluginName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetPluginName",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetPluginName",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (char *)(arg1)->GetPluginName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetShortPluginName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBProcess::GetShortPluginName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetShortPluginName",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetShortPluginName",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (char *)(arg1)->GetShortPluginName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
SWIG_check_num_args("lldb::SBProcess::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::Clear",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_Clear",1,SWIGTYPE_p_lldb__SBProcess);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBProcess::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::IsValid",1,"lldb::SBProcess const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_IsValid",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (bool)((lldb::SBProcess const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetTarget(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBTarget result;
SWIG_check_num_args("lldb::SBProcess::GetTarget",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetTarget",1,"lldb::SBProcess const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetTarget",1,SWIGTYPE_p_lldb__SBProcess);
}
result = ((lldb::SBProcess const *)arg1)->GetTarget();
{
lldb::SBTarget * resultptr = new lldb::SBTarget((const lldb::SBTarget &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetByteOrder(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::ByteOrder result;
SWIG_check_num_args("lldb::SBProcess::GetByteOrder",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetByteOrder",1,"lldb::SBProcess const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetByteOrder",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (lldb::ByteOrder)((lldb::SBProcess const *)arg1)->GetByteOrder();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_PutSTDIN(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
char *arg2 = (char *) 0 ;
size_t arg3 ;
size_t result;
SWIG_check_num_args("lldb::SBProcess::PutSTDIN",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::PutSTDIN",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_PutSTDIN",1,SWIGTYPE_p_lldb__SBProcess);
}
{
arg2 = (char *)luaL_checklstring(L, 2, &arg3);
}
result = (arg1)->PutSTDIN((char const *)arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetSTDOUT(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
char *arg2 = (char *) 0 ;
size_t arg3 ;
size_t result;
SWIG_check_num_args("lldb::SBProcess::GetSTDOUT",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetSTDOUT",1,"lldb::SBProcess const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetSTDOUT",1,SWIGTYPE_p_lldb__SBProcess);
}
{
arg3 = luaL_checkinteger(L, 2);
if (arg3 <= 0) {
return luaL_error(L, "Positive integer expected");
}
arg2 = (char *)malloc(arg3);
}
result = ((lldb::SBProcess const *)arg1)->GetSTDOUT(arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
{
lua_pop(L, 1); // Blow away the previous result
if (result == 0) {
lua_pushliteral(L, "");
} else {
lua_pushlstring(L, (const char *)arg2, result);
}
free(arg2);
// SWIG_arg was already incremented
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetSTDERR(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
char *arg2 = (char *) 0 ;
size_t arg3 ;
size_t result;
SWIG_check_num_args("lldb::SBProcess::GetSTDERR",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetSTDERR",1,"lldb::SBProcess const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetSTDERR",1,SWIGTYPE_p_lldb__SBProcess);
}
{
arg3 = luaL_checkinteger(L, 2);
if (arg3 <= 0) {
return luaL_error(L, "Positive integer expected");
}
arg2 = (char *)malloc(arg3);
}
result = ((lldb::SBProcess const *)arg1)->GetSTDERR(arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
{
lua_pop(L, 1); // Blow away the previous result
if (result == 0) {
lua_pushliteral(L, "");
} else {
lua_pushlstring(L, (const char *)arg2, result);
}
free(arg2);
// SWIG_arg was already incremented
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetAsyncProfileData(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
char *arg2 = (char *) 0 ;
size_t arg3 ;
size_t result;
SWIG_check_num_args("lldb::SBProcess::GetAsyncProfileData",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetAsyncProfileData",1,"lldb::SBProcess const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetAsyncProfileData",1,SWIGTYPE_p_lldb__SBProcess);
}
{
arg3 = luaL_checkinteger(L, 2);
if (arg3 <= 0) {
return luaL_error(L, "Positive integer expected");
}
arg2 = (char *)malloc(arg3);
}
result = ((lldb::SBProcess const *)arg1)->GetAsyncProfileData(arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
{
lua_pop(L, 1); // Blow away the previous result
if (result == 0) {
lua_pushliteral(L, "");
} else {
lua_pushlstring(L, (const char *)arg2, result);
}
free(arg2);
// SWIG_arg was already incremented
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_ReportEventState__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBEvent *arg2 = 0 ;
lldb::SBFile arg3 ;
lldb::SBFile *argp3 ;
SWIG_check_num_args("lldb::SBProcess::ReportEventState",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::ReportEventState",1,"lldb::SBProcess const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::ReportEventState",2,"lldb::SBEvent const &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBProcess::ReportEventState",3,"lldb::SBFile");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_ReportEventState",1,SWIGTYPE_p_lldb__SBProcess);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBProcess_ReportEventState",2,SWIGTYPE_p_lldb__SBEvent);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBProcess_ReportEventState",3,SWIGTYPE_p_lldb__SBFile);
}
arg3 = *argp3;
((lldb::SBProcess const *)arg1)->ReportEventState((lldb::SBEvent const &)*arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_ReportEventState__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBEvent *arg2 = 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg3 ;
SWIG_check_num_args("lldb::SBProcess::ReportEventState",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::ReportEventState",1,"lldb::SBProcess const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::ReportEventState",2,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_ReportEventState",1,SWIGTYPE_p_lldb__SBProcess);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBProcess_ReportEventState",2,SWIGTYPE_p_lldb__SBEvent);
}
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 3, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg3 = file_sp;
}
((lldb::SBProcess const *)arg1)->ReportEventState((lldb::SBEvent const &)*arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_ReportEventState(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBProcess_ReportEventState__SWIG_0(L);
}
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_isuserdata(L, argv[2])) &&
(luaL_testudata(L, argv[2], LUA_FILEHANDLE) != nullptr);
}
if (_v) {
return _wrap_SBProcess_ReportEventState__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBProcess_ReportEventState'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBProcess::ReportEventState(lldb::SBEvent const &,lldb::SBFile) const\n"
" lldb::SBProcess::ReportEventState(lldb::SBEvent const &,lldb::FileSP) const\n");
lua_error(L);return 0;
}
static int _wrap_SBProcess_AppendEventStateReport(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBEvent *arg2 = 0 ;
lldb::SBCommandReturnObject *arg3 = 0 ;
SWIG_check_num_args("lldb::SBProcess::AppendEventStateReport",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::AppendEventStateReport",1,"lldb::SBProcess *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::AppendEventStateReport",2,"lldb::SBEvent const &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBProcess::AppendEventStateReport",3,"lldb::SBCommandReturnObject &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_AppendEventStateReport",1,SWIGTYPE_p_lldb__SBProcess);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBProcess_AppendEventStateReport",2,SWIGTYPE_p_lldb__SBEvent);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){
SWIG_fail_ptr("SBProcess_AppendEventStateReport",3,SWIGTYPE_p_lldb__SBCommandReturnObject);
}
(arg1)->AppendEventStateReport((lldb::SBEvent const &)*arg2,*arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_RemoteAttachToProcessWithID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::pid_t arg2 ;
lldb::SBError *arg3 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBProcess::RemoteAttachToProcessWithID",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::RemoteAttachToProcessWithID",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::RemoteAttachToProcessWithID",2,"lldb::pid_t");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBProcess::RemoteAttachToProcessWithID",3,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_RemoteAttachToProcessWithID",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (lldb::pid_t)lua_tointeger(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBProcess_RemoteAttachToProcessWithID",3,SWIGTYPE_p_lldb__SBError);
}
result = (bool)(arg1)->RemoteAttachToProcessWithID(arg2,*arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_RemoteLaunch(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
char **arg2 = (char **) 0 ;
char **arg3 = (char **) 0 ;
char *arg4 = (char *) 0 ;
char *arg5 = (char *) 0 ;
char *arg6 = (char *) 0 ;
char *arg7 = (char *) 0 ;
uint32_t arg8 ;
bool arg9 ;
lldb::SBError *arg10 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBProcess::RemoteLaunch",10,10)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::RemoteLaunch",1,"lldb::SBProcess *");
if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBProcess::RemoteLaunch",4,"char const *");
if(!SWIG_lua_isnilstring(L,5)) SWIG_fail_arg("lldb::SBProcess::RemoteLaunch",5,"char const *");
if(!SWIG_lua_isnilstring(L,6)) SWIG_fail_arg("lldb::SBProcess::RemoteLaunch",6,"char const *");
if(!SWIG_lua_isnilstring(L,7)) SWIG_fail_arg("lldb::SBProcess::RemoteLaunch",7,"char const *");
if(!lua_isinteger(L,8)) SWIG_fail_arg("lldb::SBProcess::RemoteLaunch",8,"uint32_t");
if(!lua_isboolean(L,9)) SWIG_fail_arg("lldb::SBProcess::RemoteLaunch",9,"bool");
if(!lua_isuserdata(L,10)) SWIG_fail_arg("lldb::SBProcess::RemoteLaunch",10,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_RemoteLaunch",1,SWIGTYPE_p_lldb__SBProcess);
}
{
if (lua_istable(L, 2)) {
size_t size = lua_rawlen(L, 2);
arg2 = (char **)malloc((size + 1) * sizeof(char *));
int i = 0, j = 0;
while (i++ < size) {
lua_rawgeti(L, 2, i);
if (!lua_isstring(L, -1)) {
// if current element cannot be converted to string, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain strings");
}
arg2[j++] = (char *)lua_tostring(L, -1);
lua_pop(L, 1);
}
arg2[j] = 0;
} else if (lua_isnil(L, 2)) {
// "nil" is also acceptable, equivalent as an empty table
arg2 = NULL;
} else {
return luaL_error(L, "A list of strings expected");
}
}
{
if (lua_istable(L, 3)) {
size_t size = lua_rawlen(L, 3);
arg3 = (char **)malloc((size + 1) * sizeof(char *));
int i = 0, j = 0;
while (i++ < size) {
lua_rawgeti(L, 3, i);
if (!lua_isstring(L, -1)) {
// if current element cannot be converted to string, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain strings");
}
arg3[j++] = (char *)lua_tostring(L, -1);
lua_pop(L, 1);
}
arg3[j] = 0;
} else if (lua_isnil(L, 3)) {
// "nil" is also acceptable, equivalent as an empty table
arg3 = NULL;
} else {
return luaL_error(L, "A list of strings expected");
}
}
arg4 = (char *)lua_tostring(L, 4);
arg5 = (char *)lua_tostring(L, 5);
arg6 = (char *)lua_tostring(L, 6);
arg7 = (char *)lua_tostring(L, 7);
arg8 = (uint32_t)lua_tointeger(L, 8);
arg9 = (lua_toboolean(L, 9)!=0);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,10,(void**)&arg10,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBProcess_RemoteLaunch",10,SWIGTYPE_p_lldb__SBError);
}
result = (bool)(arg1)->RemoteLaunch((char const **)arg2,(char const **)arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,arg8,arg9,*arg10);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
{
free((char *) arg2);
}
{
free((char *) arg3);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free((char *) arg2);
}
{
free((char *) arg3);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetNumThreads(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBProcess::GetNumThreads",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetNumThreads",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetNumThreads",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (uint32_t)(arg1)->GetNumThreads();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetThreadAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
size_t arg2 ;
lldb::SBThread result;
SWIG_check_num_args("lldb::SBProcess::GetThreadAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetThreadAtIndex",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetThreadAtIndex",2,"size_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetThreadAtIndex",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (size_t)lua_tointeger(L, 2);
result = (arg1)->GetThreadAtIndex(arg2);
{
lldb::SBThread * resultptr = new lldb::SBThread((const lldb::SBThread &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetThreadByID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::tid_t arg2 ;
lldb::SBThread result;
SWIG_check_num_args("lldb::SBProcess::GetThreadByID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetThreadByID",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetThreadByID",2,"lldb::tid_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetThreadByID",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (lldb::tid_t)lua_tointeger(L, 2);
result = (arg1)->GetThreadByID(arg2);
{
lldb::SBThread * resultptr = new lldb::SBThread((const lldb::SBThread &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetThreadByIndexID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
uint32_t arg2 ;
lldb::SBThread result;
SWIG_check_num_args("lldb::SBProcess::GetThreadByIndexID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetThreadByIndexID",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetThreadByIndexID",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetThreadByIndexID",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetThreadByIndexID(arg2);
{
lldb::SBThread * resultptr = new lldb::SBThread((const lldb::SBThread &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetSelectedThread(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBThread result;
SWIG_check_num_args("lldb::SBProcess::GetSelectedThread",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetSelectedThread",1,"lldb::SBProcess const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetSelectedThread",1,SWIGTYPE_p_lldb__SBProcess);
}
result = ((lldb::SBProcess const *)arg1)->GetSelectedThread();
{
lldb::SBThread * resultptr = new lldb::SBThread((const lldb::SBThread &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_CreateOSPluginThread(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::tid_t arg2 ;
lldb::addr_t arg3 ;
lldb::SBThread result;
SWIG_check_num_args("lldb::SBProcess::CreateOSPluginThread",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::CreateOSPluginThread",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::CreateOSPluginThread",2,"lldb::tid_t");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBProcess::CreateOSPluginThread",3,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_CreateOSPluginThread",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (lldb::tid_t)lua_tointeger(L, 2);
arg3 = (lldb::addr_t)lua_tointeger(L, 3);
result = (arg1)->CreateOSPluginThread(arg2,arg3);
{
lldb::SBThread * resultptr = new lldb::SBThread((const lldb::SBThread &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_SetSelectedThread(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBThread *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBProcess::SetSelectedThread",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::SetSelectedThread",1,"lldb::SBProcess *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::SetSelectedThread",2,"lldb::SBThread const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_SetSelectedThread",1,SWIGTYPE_p_lldb__SBProcess);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBProcess_SetSelectedThread",2,SWIGTYPE_p_lldb__SBThread);
}
result = (bool)(arg1)->SetSelectedThread((lldb::SBThread const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_SetSelectedThreadByID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::tid_t arg2 ;
bool result;
SWIG_check_num_args("lldb::SBProcess::SetSelectedThreadByID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::SetSelectedThreadByID",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::SetSelectedThreadByID",2,"lldb::tid_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_SetSelectedThreadByID",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (lldb::tid_t)lua_tointeger(L, 2);
result = (bool)(arg1)->SetSelectedThreadByID(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_SetSelectedThreadByIndexID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
uint32_t arg2 ;
bool result;
SWIG_check_num_args("lldb::SBProcess::SetSelectedThreadByIndexID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::SetSelectedThreadByIndexID",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::SetSelectedThreadByIndexID",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_SetSelectedThreadByIndexID",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (bool)(arg1)->SetSelectedThreadByIndexID(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetNumQueues(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBProcess::GetNumQueues",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetNumQueues",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetNumQueues",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (uint32_t)(arg1)->GetNumQueues();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetQueueAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
uint32_t arg2 ;
lldb::SBQueue result;
SWIG_check_num_args("lldb::SBProcess::GetQueueAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetQueueAtIndex",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetQueueAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetQueueAtIndex",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetQueueAtIndex(arg2);
{
lldb::SBQueue * resultptr = new lldb::SBQueue((const lldb::SBQueue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBQueue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetState(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::StateType result;
SWIG_check_num_args("lldb::SBProcess::GetState",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetState",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetState",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (lldb::StateType)(arg1)->GetState();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetExitStatus(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
int result;
SWIG_check_num_args("lldb::SBProcess::GetExitStatus",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetExitStatus",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetExitStatus",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (int)(arg1)->GetExitStatus();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetExitDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBProcess::GetExitDescription",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetExitDescription",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetExitDescription",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (char *)(arg1)->GetExitDescription();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetProcessID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::pid_t result;
SWIG_check_num_args("lldb::SBProcess::GetProcessID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetProcessID",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetProcessID",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (lldb::pid_t)(arg1)->GetProcessID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetUniqueID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBProcess::GetUniqueID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetUniqueID",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetUniqueID",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (uint32_t)(arg1)->GetUniqueID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetAddressByteSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBProcess::GetAddressByteSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetAddressByteSize",1,"lldb::SBProcess const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetAddressByteSize",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (uint32_t)((lldb::SBProcess const *)arg1)->GetAddressByteSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_Destroy(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBProcess::Destroy",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::Destroy",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_Destroy",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (arg1)->Destroy();
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_Continue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBProcess::Continue",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::Continue",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_Continue",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (arg1)->Continue();
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_Stop(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBProcess::Stop",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::Stop",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_Stop",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (arg1)->Stop();
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_Kill(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBProcess::Kill",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::Kill",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_Kill",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (arg1)->Kill();
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_Detach(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBProcess::Detach",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::Detach",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_Detach",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (arg1)->Detach();
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_Signal(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
int arg2 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBProcess::Signal",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::Signal",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::Signal",2,"int");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_Signal",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (int)lua_tointeger(L, 2);
result = (arg1)->Signal(arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetUnixSignals(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBUnixSignals result;
SWIG_check_num_args("lldb::SBProcess::GetUnixSignals",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetUnixSignals",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetUnixSignals",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (arg1)->GetUnixSignals();
{
lldb::SBUnixSignals * resultptr = new lldb::SBUnixSignals((const lldb::SBUnixSignals &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBUnixSignals,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetStopID__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
bool arg2 ;
uint32_t result;
SWIG_check_num_args("lldb::SBProcess::GetStopID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetStopID",1,"lldb::SBProcess *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBProcess::GetStopID",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetStopID",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (lua_toboolean(L, 2)!=0);
result = (uint32_t)(arg1)->GetStopID(arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetStopID__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBProcess::GetStopID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetStopID",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetStopID",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (uint32_t)(arg1)->GetStopID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetStopID(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBProcess_GetStopID__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_SBProcess_GetStopID__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBProcess_GetStopID'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBProcess::GetStopID(bool)\n"
" lldb::SBProcess::GetStopID()\n");
lua_error(L);return 0;
}
static int _wrap_SBProcess_SendAsyncInterrupt(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
SWIG_check_num_args("lldb::SBProcess::SendAsyncInterrupt",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::SendAsyncInterrupt",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_SendAsyncInterrupt",1,SWIGTYPE_p_lldb__SBProcess);
}
(arg1)->SendAsyncInterrupt();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_ReadMemory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::addr_t arg2 ;
void *arg3 = (void *) 0 ;
size_t arg4 ;
lldb::SBError *arg5 = 0 ;
size_t result;
SWIG_check_num_args("lldb::SBProcess::ReadMemory",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::ReadMemory",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::ReadMemory",2,"lldb::addr_t");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBProcess::ReadMemory",4,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_ReadMemory",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
{
arg4 = luaL_checkinteger(L, 3);
if (arg4 <= 0) {
return luaL_error(L, "Positive integer expected");
}
arg3 = (char *)malloc(arg4);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBProcess_ReadMemory",5,SWIGTYPE_p_lldb__SBError);
}
result = (arg1)->ReadMemory(arg2,arg3,arg4,*arg5);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
{
lua_pop(L, 1); // Blow away the previous result
if (result == 0) {
lua_pushliteral(L, "");
} else {
lua_pushlstring(L, (const char *)arg3, result);
}
free(arg3);
// SWIG_arg was already incremented
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_WriteMemory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::addr_t arg2 ;
void *arg3 = (void *) 0 ;
size_t arg4 ;
lldb::SBError *arg5 = 0 ;
size_t result;
SWIG_check_num_args("lldb::SBProcess::WriteMemory",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::WriteMemory",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::WriteMemory",2,"lldb::addr_t");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBProcess::WriteMemory",4,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_WriteMemory",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
{
arg3 = (void *)luaL_checklstring(L, 3, &arg4);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBProcess_WriteMemory",5,SWIGTYPE_p_lldb__SBError);
}
result = (arg1)->WriteMemory(arg2,(void const *)arg3,arg4,*arg5);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_ReadCStringFromMemory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::addr_t arg2 ;
void *arg3 = (void *) 0 ;
size_t arg4 ;
lldb::SBError *arg5 = 0 ;
size_t result;
SWIG_check_num_args("lldb::SBProcess::ReadCStringFromMemory",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::ReadCStringFromMemory",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::ReadCStringFromMemory",2,"lldb::addr_t");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBProcess::ReadCStringFromMemory",4,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_ReadCStringFromMemory",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
{
arg4 = luaL_checkinteger(L, 3);
if (arg4 <= 0) {
return luaL_error(L, "Positive integer expected");
}
arg3 = (char *)malloc(arg4);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBProcess_ReadCStringFromMemory",5,SWIGTYPE_p_lldb__SBError);
}
result = (arg1)->ReadCStringFromMemory(arg2,arg3,arg4,*arg5);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
{
lua_pop(L, 1); // Blow away the previous result
if (result == 0) {
lua_pushliteral(L, "");
} else {
lua_pushlstring(L, (const char *)arg3, result);
}
free(arg3);
// SWIG_arg was already incremented
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_ReadUnsignedFromMemory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::addr_t arg2 ;
uint32_t arg3 ;
lldb::SBError *arg4 = 0 ;
uint64_t result;
SWIG_check_num_args("lldb::SBProcess::ReadUnsignedFromMemory",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::ReadUnsignedFromMemory",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::ReadUnsignedFromMemory",2,"lldb::addr_t");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBProcess::ReadUnsignedFromMemory",3,"uint32_t");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBProcess::ReadUnsignedFromMemory",4,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_ReadUnsignedFromMemory",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBProcess_ReadUnsignedFromMemory",4,SWIGTYPE_p_lldb__SBError);
}
result = (uint64_t)(arg1)->ReadUnsignedFromMemory(arg2,arg3,*arg4);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_ReadPointerFromMemory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::addr_t arg2 ;
lldb::SBError *arg3 = 0 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBProcess::ReadPointerFromMemory",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::ReadPointerFromMemory",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::ReadPointerFromMemory",2,"lldb::addr_t");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBProcess::ReadPointerFromMemory",3,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_ReadPointerFromMemory",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBProcess_ReadPointerFromMemory",3,SWIGTYPE_p_lldb__SBError);
}
result = (lldb::addr_t)(arg1)->ReadPointerFromMemory(arg2,*arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetStateFromEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
lldb::StateType result;
SWIG_check_num_args("lldb::SBProcess::GetStateFromEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::GetStateFromEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBProcess_GetStateFromEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (lldb::StateType)lldb::SBProcess::GetStateFromEvent((lldb::SBEvent const &)*arg1);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetRestartedFromEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBProcess::GetRestartedFromEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::GetRestartedFromEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBProcess_GetRestartedFromEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)lldb::SBProcess::GetRestartedFromEvent((lldb::SBEvent const &)*arg1);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetNumRestartedReasonsFromEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
size_t result;
SWIG_check_num_args("lldb::SBProcess::GetNumRestartedReasonsFromEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::GetNumRestartedReasonsFromEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBProcess_GetNumRestartedReasonsFromEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = lldb::SBProcess::GetNumRestartedReasonsFromEvent((lldb::SBEvent const &)*arg1);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetRestartedReasonAtIndexFromEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
size_t arg2 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBProcess::GetRestartedReasonAtIndexFromEvent",2,2)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::GetRestartedReasonAtIndexFromEvent",1,"lldb::SBEvent const &");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetRestartedReasonAtIndexFromEvent",2,"size_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBProcess_GetRestartedReasonAtIndexFromEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
arg2 = (size_t)lua_tointeger(L, 2);
result = (char *)lldb::SBProcess::GetRestartedReasonAtIndexFromEvent((lldb::SBEvent const &)*arg1,arg2);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetProcessFromEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
lldb::SBProcess result;
SWIG_check_num_args("lldb::SBProcess::GetProcessFromEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::GetProcessFromEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBProcess_GetProcessFromEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = lldb::SBProcess::GetProcessFromEvent((lldb::SBEvent const &)*arg1);
{
lldb::SBProcess * resultptr = new lldb::SBProcess((const lldb::SBProcess &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetInterruptedFromEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBProcess::GetInterruptedFromEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::GetInterruptedFromEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBProcess_GetInterruptedFromEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)lldb::SBProcess::GetInterruptedFromEvent((lldb::SBEvent const &)*arg1);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetStructuredDataFromEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
lldb::SBStructuredData result;
SWIG_check_num_args("lldb::SBProcess::GetStructuredDataFromEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::GetStructuredDataFromEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBProcess_GetStructuredDataFromEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = lldb::SBProcess::GetStructuredDataFromEvent((lldb::SBEvent const &)*arg1);
{
lldb::SBStructuredData * resultptr = new lldb::SBStructuredData((const lldb::SBStructuredData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_EventIsProcessEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBProcess::EventIsProcessEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::EventIsProcessEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBProcess_EventIsProcessEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)lldb::SBProcess::EventIsProcessEvent((lldb::SBEvent const &)*arg1);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_EventIsStructuredDataEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBProcess::EventIsStructuredDataEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::EventIsStructuredDataEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBProcess_EventIsStructuredDataEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)lldb::SBProcess::EventIsStructuredDataEvent((lldb::SBEvent const &)*arg1);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetBroadcaster(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBBroadcaster result;
SWIG_check_num_args("lldb::SBProcess::GetBroadcaster",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetBroadcaster",1,"lldb::SBProcess const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetBroadcaster",1,SWIGTYPE_p_lldb__SBProcess);
}
result = ((lldb::SBProcess const *)arg1)->GetBroadcaster();
{
lldb::SBBroadcaster * resultptr = new lldb::SBBroadcaster((const lldb::SBBroadcaster &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBroadcaster,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBProcess::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetDescription",1,"lldb::SBProcess *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetDescription",1,SWIGTYPE_p_lldb__SBProcess);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBProcess_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetExtendedCrashInformation(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBStructuredData result;
SWIG_check_num_args("lldb::SBProcess::GetExtendedCrashInformation",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetExtendedCrashInformation",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetExtendedCrashInformation",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (arg1)->GetExtendedCrashInformation();
{
lldb::SBStructuredData * resultptr = new lldb::SBStructuredData((const lldb::SBStructuredData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetNumSupportedHardwareWatchpoints(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBError *arg2 = 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBProcess::GetNumSupportedHardwareWatchpoints",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetNumSupportedHardwareWatchpoints",1,"lldb::SBProcess const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::GetNumSupportedHardwareWatchpoints",2,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetNumSupportedHardwareWatchpoints",1,SWIGTYPE_p_lldb__SBProcess);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBProcess_GetNumSupportedHardwareWatchpoints",2,SWIGTYPE_p_lldb__SBError);
}
result = (uint32_t)((lldb::SBProcess const *)arg1)->GetNumSupportedHardwareWatchpoints(*arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_LoadImage(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
lldb::SBError *arg3 = 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBProcess::LoadImage",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::LoadImage",1,"lldb::SBProcess *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::LoadImage",2,"lldb::SBFileSpec &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBProcess::LoadImage",3,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_LoadImage",1,SWIGTYPE_p_lldb__SBProcess);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBProcess_LoadImage",2,SWIGTYPE_p_lldb__SBFileSpec);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBProcess_LoadImage",3,SWIGTYPE_p_lldb__SBError);
}
result = (uint32_t)(arg1)->LoadImage(*arg2,*arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_LoadImageUsingPaths(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
lldb::SBStringList *arg3 = 0 ;
lldb::SBFileSpec *arg4 = 0 ;
lldb::SBError *arg5 = 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBProcess::LoadImageUsingPaths",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::LoadImageUsingPaths",1,"lldb::SBProcess *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::LoadImageUsingPaths",2,"lldb::SBFileSpec const &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBProcess::LoadImageUsingPaths",3,"lldb::SBStringList &");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBProcess::LoadImageUsingPaths",4,"lldb::SBFileSpec &");
if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBProcess::LoadImageUsingPaths",5,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_LoadImageUsingPaths",1,SWIGTYPE_p_lldb__SBProcess);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBProcess_LoadImageUsingPaths",2,SWIGTYPE_p_lldb__SBFileSpec);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBProcess_LoadImageUsingPaths",3,SWIGTYPE_p_lldb__SBStringList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBProcess_LoadImageUsingPaths",4,SWIGTYPE_p_lldb__SBFileSpec);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBProcess_LoadImageUsingPaths",5,SWIGTYPE_p_lldb__SBError);
}
result = (uint32_t)(arg1)->LoadImageUsingPaths((lldb::SBFileSpec const &)*arg2,*arg3,*arg4,*arg5);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_UnloadImage(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
uint32_t arg2 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBProcess::UnloadImage",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::UnloadImage",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::UnloadImage",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_UnloadImage",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->UnloadImage(arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_SendEventData(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBProcess::SendEventData",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::SendEventData",1,"lldb::SBProcess *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBProcess::SendEventData",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_SendEventData",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->SendEventData((char const *)arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetNumExtendedBacktraceTypes(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBProcess::GetNumExtendedBacktraceTypes",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetNumExtendedBacktraceTypes",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetNumExtendedBacktraceTypes",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (uint32_t)(arg1)->GetNumExtendedBacktraceTypes();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetExtendedBacktraceTypeAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
uint32_t arg2 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBProcess::GetExtendedBacktraceTypeAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetExtendedBacktraceTypeAtIndex",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetExtendedBacktraceTypeAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetExtendedBacktraceTypeAtIndex",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (char *)(arg1)->GetExtendedBacktraceTypeAtIndex(arg2);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetHistoryThreads(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::addr_t arg2 ;
lldb::SBThreadCollection result;
SWIG_check_num_args("lldb::SBProcess::GetHistoryThreads",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetHistoryThreads",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetHistoryThreads",2,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetHistoryThreads",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
result = (arg1)->GetHistoryThreads(arg2);
{
lldb::SBThreadCollection * resultptr = new lldb::SBThreadCollection((const lldb::SBThreadCollection &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadCollection,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_IsInstrumentationRuntimePresent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::InstrumentationRuntimeType arg2 ;
bool result;
SWIG_check_num_args("lldb::SBProcess::IsInstrumentationRuntimePresent",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::IsInstrumentationRuntimePresent",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::IsInstrumentationRuntimePresent",2,"lldb::InstrumentationRuntimeType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_IsInstrumentationRuntimePresent",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (lldb::InstrumentationRuntimeType)lua_tointeger(L, 2);
result = (bool)(arg1)->IsInstrumentationRuntimePresent(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_SaveCore(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBProcess::SaveCore",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::SaveCore",1,"lldb::SBProcess *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBProcess::SaveCore",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_SaveCore",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->SaveCore((char const *)arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetMemoryRegionInfo(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::addr_t arg2 ;
lldb::SBMemoryRegionInfo *arg3 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBProcess::GetMemoryRegionInfo",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetMemoryRegionInfo",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetMemoryRegionInfo",2,"lldb::addr_t");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBProcess::GetMemoryRegionInfo",3,"lldb::SBMemoryRegionInfo &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetMemoryRegionInfo",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){
SWIG_fail_ptr("SBProcess_GetMemoryRegionInfo",3,SWIGTYPE_p_lldb__SBMemoryRegionInfo);
}
result = (arg1)->GetMemoryRegionInfo(arg2,*arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetMemoryRegions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBMemoryRegionInfoList result;
SWIG_check_num_args("lldb::SBProcess::GetMemoryRegions",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetMemoryRegions",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetMemoryRegions",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (arg1)->GetMemoryRegions();
{
lldb::SBMemoryRegionInfoList * resultptr = new lldb::SBMemoryRegionInfoList((const lldb::SBMemoryRegionInfoList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_GetProcessInfo(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::SBProcessInfo result;
SWIG_check_num_args("lldb::SBProcess::GetProcessInfo",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetProcessInfo",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_GetProcessInfo",1,SWIGTYPE_p_lldb__SBProcess);
}
result = (arg1)->GetProcessInfo();
{
lldb::SBProcessInfo * resultptr = new lldb::SBProcessInfo((const lldb::SBProcessInfo &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcessInfo,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_AllocateMemory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
size_t arg2 ;
uint32_t arg3 ;
lldb::SBError *arg4 = 0 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBProcess::AllocateMemory",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::AllocateMemory",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::AllocateMemory",2,"size_t");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBProcess::AllocateMemory",3,"uint32_t");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBProcess::AllocateMemory",4,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_AllocateMemory",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (size_t)lua_tointeger(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBProcess_AllocateMemory",4,SWIGTYPE_p_lldb__SBError);
}
result = (lldb::addr_t)(arg1)->AllocateMemory(arg2,arg3,*arg4);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess_DeallocateMemory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
lldb::addr_t arg2 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBProcess::DeallocateMemory",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::DeallocateMemory",1,"lldb::SBProcess *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::DeallocateMemory",2,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess_DeallocateMemory",1,SWIGTYPE_p_lldb__SBProcess);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
result = (arg1)->DeallocateMemory(arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcess___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBProcess::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::__str__",1,"lldb::SBProcess *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){
SWIG_fail_ptr("SBProcess___tostring",1,SWIGTYPE_p_lldb__SBProcess);
}
result = lldb_SBProcess___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBProcess(void *obj) {
lldb::SBProcess *arg1 = (lldb::SBProcess *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBProcess(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBProcess);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBProcess_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBProcess_methods[]= {
{ "GetPluginName", _wrap_SBProcess_GetPluginName},
{ "GetShortPluginName", _wrap_SBProcess_GetShortPluginName},
{ "Clear", _wrap_SBProcess_Clear},
{ "IsValid", _wrap_SBProcess_IsValid},
{ "GetTarget", _wrap_SBProcess_GetTarget},
{ "GetByteOrder", _wrap_SBProcess_GetByteOrder},
{ "PutSTDIN", _wrap_SBProcess_PutSTDIN},
{ "GetSTDOUT", _wrap_SBProcess_GetSTDOUT},
{ "GetSTDERR", _wrap_SBProcess_GetSTDERR},
{ "GetAsyncProfileData", _wrap_SBProcess_GetAsyncProfileData},
{ "ReportEventState", _wrap_SBProcess_ReportEventState},
{ "AppendEventStateReport", _wrap_SBProcess_AppendEventStateReport},
{ "RemoteAttachToProcessWithID", _wrap_SBProcess_RemoteAttachToProcessWithID},
{ "RemoteLaunch", _wrap_SBProcess_RemoteLaunch},
{ "GetNumThreads", _wrap_SBProcess_GetNumThreads},
{ "GetThreadAtIndex", _wrap_SBProcess_GetThreadAtIndex},
{ "GetThreadByID", _wrap_SBProcess_GetThreadByID},
{ "GetThreadByIndexID", _wrap_SBProcess_GetThreadByIndexID},
{ "GetSelectedThread", _wrap_SBProcess_GetSelectedThread},
{ "CreateOSPluginThread", _wrap_SBProcess_CreateOSPluginThread},
{ "SetSelectedThread", _wrap_SBProcess_SetSelectedThread},
{ "SetSelectedThreadByID", _wrap_SBProcess_SetSelectedThreadByID},
{ "SetSelectedThreadByIndexID", _wrap_SBProcess_SetSelectedThreadByIndexID},
{ "GetNumQueues", _wrap_SBProcess_GetNumQueues},
{ "GetQueueAtIndex", _wrap_SBProcess_GetQueueAtIndex},
{ "GetState", _wrap_SBProcess_GetState},
{ "GetExitStatus", _wrap_SBProcess_GetExitStatus},
{ "GetExitDescription", _wrap_SBProcess_GetExitDescription},
{ "GetProcessID", _wrap_SBProcess_GetProcessID},
{ "GetUniqueID", _wrap_SBProcess_GetUniqueID},
{ "GetAddressByteSize", _wrap_SBProcess_GetAddressByteSize},
{ "Destroy", _wrap_SBProcess_Destroy},
{ "Continue", _wrap_SBProcess_Continue},
{ "Stop", _wrap_SBProcess_Stop},
{ "Kill", _wrap_SBProcess_Kill},
{ "Detach", _wrap_SBProcess_Detach},
{ "Signal", _wrap_SBProcess_Signal},
{ "GetUnixSignals", _wrap_SBProcess_GetUnixSignals},
{ "GetStopID", _wrap_SBProcess_GetStopID},
{ "SendAsyncInterrupt", _wrap_SBProcess_SendAsyncInterrupt},
{ "ReadMemory", _wrap_SBProcess_ReadMemory},
{ "WriteMemory", _wrap_SBProcess_WriteMemory},
{ "ReadCStringFromMemory", _wrap_SBProcess_ReadCStringFromMemory},
{ "ReadUnsignedFromMemory", _wrap_SBProcess_ReadUnsignedFromMemory},
{ "ReadPointerFromMemory", _wrap_SBProcess_ReadPointerFromMemory},
{ "GetBroadcaster", _wrap_SBProcess_GetBroadcaster},
{ "GetDescription", _wrap_SBProcess_GetDescription},
{ "GetExtendedCrashInformation", _wrap_SBProcess_GetExtendedCrashInformation},
{ "GetNumSupportedHardwareWatchpoints", _wrap_SBProcess_GetNumSupportedHardwareWatchpoints},
{ "LoadImage", _wrap_SBProcess_LoadImage},
{ "LoadImageUsingPaths", _wrap_SBProcess_LoadImageUsingPaths},
{ "UnloadImage", _wrap_SBProcess_UnloadImage},
{ "SendEventData", _wrap_SBProcess_SendEventData},
{ "GetNumExtendedBacktraceTypes", _wrap_SBProcess_GetNumExtendedBacktraceTypes},
{ "GetExtendedBacktraceTypeAtIndex", _wrap_SBProcess_GetExtendedBacktraceTypeAtIndex},
{ "GetHistoryThreads", _wrap_SBProcess_GetHistoryThreads},
{ "IsInstrumentationRuntimePresent", _wrap_SBProcess_IsInstrumentationRuntimePresent},
{ "SaveCore", _wrap_SBProcess_SaveCore},
{ "GetMemoryRegionInfo", _wrap_SBProcess_GetMemoryRegionInfo},
{ "GetMemoryRegions", _wrap_SBProcess_GetMemoryRegions},
{ "GetProcessInfo", _wrap_SBProcess_GetProcessInfo},
{ "AllocateMemory", _wrap_SBProcess_AllocateMemory},
{ "DeallocateMemory", _wrap_SBProcess_DeallocateMemory},
{ "__tostring", _wrap_SBProcess___tostring},
{0,0}
};
static swig_lua_method swig_SBProcess_meta[] = {
{ "__tostring", _wrap_SBProcess___tostring},
{0,0}
};
static swig_lua_attribute swig_SBProcess_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBProcess_Sf_SwigStatic_constants[]= {
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitStateChanged", lldb::SBProcess::eBroadcastBitStateChanged)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitInterrupt", lldb::SBProcess::eBroadcastBitInterrupt)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitSTDOUT", lldb::SBProcess::eBroadcastBitSTDOUT)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitSTDERR", lldb::SBProcess::eBroadcastBitSTDERR)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitProfileData", lldb::SBProcess::eBroadcastBitProfileData)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitStructuredData", lldb::SBProcess::eBroadcastBitStructuredData)},
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBProcess_Sf_SwigStatic_methods[]= {
{ "GetBroadcasterClassName", _wrap_SBProcess_GetBroadcasterClassName},
{ "GetStateFromEvent", _wrap_SBProcess_GetStateFromEvent},
{ "GetRestartedFromEvent", _wrap_SBProcess_GetRestartedFromEvent},
{ "GetNumRestartedReasonsFromEvent", _wrap_SBProcess_GetNumRestartedReasonsFromEvent},
{ "GetRestartedReasonAtIndexFromEvent", _wrap_SBProcess_GetRestartedReasonAtIndexFromEvent},
{ "GetProcessFromEvent", _wrap_SBProcess_GetProcessFromEvent},
{ "GetInterruptedFromEvent", _wrap_SBProcess_GetInterruptedFromEvent},
{ "GetStructuredDataFromEvent", _wrap_SBProcess_GetStructuredDataFromEvent},
{ "EventIsProcessEvent", _wrap_SBProcess_EventIsProcessEvent},
{ "EventIsStructuredDataEvent", _wrap_SBProcess_EventIsStructuredDataEvent},
{0,0}
};
static swig_lua_class* swig_SBProcess_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBProcess_Sf_SwigStatic = {
"SBProcess",
swig_SBProcess_Sf_SwigStatic_methods,
swig_SBProcess_Sf_SwigStatic_attributes,
swig_SBProcess_Sf_SwigStatic_constants,
swig_SBProcess_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBProcess_bases[] = {0};
static const char *swig_SBProcess_base_names[] = {0};
static swig_lua_class _wrap_class_SBProcess = { "SBProcess", "SBProcess", &SWIGTYPE_p_lldb__SBProcess,_proxy__wrap_new_SBProcess, swig_delete_SBProcess, swig_SBProcess_methods, swig_SBProcess_attributes, &swig_SBProcess_Sf_SwigStatic, swig_SBProcess_meta, swig_SBProcess_bases, swig_SBProcess_base_names };
static int _wrap_new_SBProcessInfo__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcessInfo *result = 0 ;
SWIG_check_num_args("lldb::SBProcessInfo::SBProcessInfo",0,0)
result = (lldb::SBProcessInfo *)new lldb::SBProcessInfo();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBProcessInfo,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBProcessInfo__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcessInfo *arg1 = 0 ;
lldb::SBProcessInfo *result = 0 ;
SWIG_check_num_args("lldb::SBProcessInfo::SBProcessInfo",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::SBProcessInfo",1,"lldb::SBProcessInfo const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){
SWIG_fail_ptr("new_SBProcessInfo",1,SWIGTYPE_p_lldb__SBProcessInfo);
}
result = (lldb::SBProcessInfo *)new lldb::SBProcessInfo((lldb::SBProcessInfo const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBProcessInfo,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBProcessInfo(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBProcessInfo__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcessInfo, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBProcessInfo__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBProcessInfo'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBProcessInfo::SBProcessInfo()\n"
" lldb::SBProcessInfo::SBProcessInfo(lldb::SBProcessInfo const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBProcessInfo_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBProcessInfo::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::IsValid",1,"lldb::SBProcessInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){
SWIG_fail_ptr("SBProcessInfo_IsValid",1,SWIGTYPE_p_lldb__SBProcessInfo);
}
result = (bool)(arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcessInfo_GetName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBProcessInfo::GetName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GetName",1,"lldb::SBProcessInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){
SWIG_fail_ptr("SBProcessInfo_GetName",1,SWIGTYPE_p_lldb__SBProcessInfo);
}
result = (char *)(arg1)->GetName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcessInfo_GetExecutableFile(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBProcessInfo::GetExecutableFile",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GetExecutableFile",1,"lldb::SBProcessInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){
SWIG_fail_ptr("SBProcessInfo_GetExecutableFile",1,SWIGTYPE_p_lldb__SBProcessInfo);
}
result = (arg1)->GetExecutableFile();
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcessInfo_GetProcessID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ;
lldb::pid_t result;
SWIG_check_num_args("lldb::SBProcessInfo::GetProcessID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GetProcessID",1,"lldb::SBProcessInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){
SWIG_fail_ptr("SBProcessInfo_GetProcessID",1,SWIGTYPE_p_lldb__SBProcessInfo);
}
result = (lldb::pid_t)(arg1)->GetProcessID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcessInfo_GetUserID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBProcessInfo::GetUserID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GetUserID",1,"lldb::SBProcessInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){
SWIG_fail_ptr("SBProcessInfo_GetUserID",1,SWIGTYPE_p_lldb__SBProcessInfo);
}
result = (uint32_t)(arg1)->GetUserID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcessInfo_GetGroupID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBProcessInfo::GetGroupID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GetGroupID",1,"lldb::SBProcessInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){
SWIG_fail_ptr("SBProcessInfo_GetGroupID",1,SWIGTYPE_p_lldb__SBProcessInfo);
}
result = (uint32_t)(arg1)->GetGroupID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcessInfo_UserIDIsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBProcessInfo::UserIDIsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::UserIDIsValid",1,"lldb::SBProcessInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){
SWIG_fail_ptr("SBProcessInfo_UserIDIsValid",1,SWIGTYPE_p_lldb__SBProcessInfo);
}
result = (bool)(arg1)->UserIDIsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcessInfo_GroupIDIsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBProcessInfo::GroupIDIsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GroupIDIsValid",1,"lldb::SBProcessInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){
SWIG_fail_ptr("SBProcessInfo_GroupIDIsValid",1,SWIGTYPE_p_lldb__SBProcessInfo);
}
result = (bool)(arg1)->GroupIDIsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcessInfo_GetEffectiveUserID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBProcessInfo::GetEffectiveUserID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GetEffectiveUserID",1,"lldb::SBProcessInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){
SWIG_fail_ptr("SBProcessInfo_GetEffectiveUserID",1,SWIGTYPE_p_lldb__SBProcessInfo);
}
result = (uint32_t)(arg1)->GetEffectiveUserID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcessInfo_GetEffectiveGroupID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBProcessInfo::GetEffectiveGroupID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GetEffectiveGroupID",1,"lldb::SBProcessInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){
SWIG_fail_ptr("SBProcessInfo_GetEffectiveGroupID",1,SWIGTYPE_p_lldb__SBProcessInfo);
}
result = (uint32_t)(arg1)->GetEffectiveGroupID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcessInfo_EffectiveUserIDIsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBProcessInfo::EffectiveUserIDIsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::EffectiveUserIDIsValid",1,"lldb::SBProcessInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){
SWIG_fail_ptr("SBProcessInfo_EffectiveUserIDIsValid",1,SWIGTYPE_p_lldb__SBProcessInfo);
}
result = (bool)(arg1)->EffectiveUserIDIsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcessInfo_EffectiveGroupIDIsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBProcessInfo::EffectiveGroupIDIsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::EffectiveGroupIDIsValid",1,"lldb::SBProcessInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){
SWIG_fail_ptr("SBProcessInfo_EffectiveGroupIDIsValid",1,SWIGTYPE_p_lldb__SBProcessInfo);
}
result = (bool)(arg1)->EffectiveGroupIDIsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcessInfo_GetParentProcessID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ;
lldb::pid_t result;
SWIG_check_num_args("lldb::SBProcessInfo::GetParentProcessID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GetParentProcessID",1,"lldb::SBProcessInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){
SWIG_fail_ptr("SBProcessInfo_GetParentProcessID",1,SWIGTYPE_p_lldb__SBProcessInfo);
}
result = (lldb::pid_t)(arg1)->GetParentProcessID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBProcessInfo_GetTriple(lua_State* L) {
int SWIG_arg = 0;
lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBProcessInfo::GetTriple",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GetTriple",1,"lldb::SBProcessInfo *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){
SWIG_fail_ptr("SBProcessInfo_GetTriple",1,SWIGTYPE_p_lldb__SBProcessInfo);
}
result = (char *)(arg1)->GetTriple();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBProcessInfo(void *obj) {
lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBProcessInfo(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBProcessInfo);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBProcessInfo_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBProcessInfo_methods[]= {
{ "IsValid", _wrap_SBProcessInfo_IsValid},
{ "GetName", _wrap_SBProcessInfo_GetName},
{ "GetExecutableFile", _wrap_SBProcessInfo_GetExecutableFile},
{ "GetProcessID", _wrap_SBProcessInfo_GetProcessID},
{ "GetUserID", _wrap_SBProcessInfo_GetUserID},
{ "GetGroupID", _wrap_SBProcessInfo_GetGroupID},
{ "UserIDIsValid", _wrap_SBProcessInfo_UserIDIsValid},
{ "GroupIDIsValid", _wrap_SBProcessInfo_GroupIDIsValid},
{ "GetEffectiveUserID", _wrap_SBProcessInfo_GetEffectiveUserID},
{ "GetEffectiveGroupID", _wrap_SBProcessInfo_GetEffectiveGroupID},
{ "EffectiveUserIDIsValid", _wrap_SBProcessInfo_EffectiveUserIDIsValid},
{ "EffectiveGroupIDIsValid", _wrap_SBProcessInfo_EffectiveGroupIDIsValid},
{ "GetParentProcessID", _wrap_SBProcessInfo_GetParentProcessID},
{ "GetTriple", _wrap_SBProcessInfo_GetTriple},
{0,0}
};
static swig_lua_method swig_SBProcessInfo_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBProcessInfo_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBProcessInfo_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBProcessInfo_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBProcessInfo_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBProcessInfo_Sf_SwigStatic = {
"SBProcessInfo",
swig_SBProcessInfo_Sf_SwigStatic_methods,
swig_SBProcessInfo_Sf_SwigStatic_attributes,
swig_SBProcessInfo_Sf_SwigStatic_constants,
swig_SBProcessInfo_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBProcessInfo_bases[] = {0};
static const char *swig_SBProcessInfo_base_names[] = {0};
static swig_lua_class _wrap_class_SBProcessInfo = { "SBProcessInfo", "SBProcessInfo", &SWIGTYPE_p_lldb__SBProcessInfo,_proxy__wrap_new_SBProcessInfo, swig_delete_SBProcessInfo, swig_SBProcessInfo_methods, swig_SBProcessInfo_attributes, &swig_SBProcessInfo_Sf_SwigStatic, swig_SBProcessInfo_meta, swig_SBProcessInfo_bases, swig_SBProcessInfo_base_names };
static int _wrap_new_SBQueue__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueue *result = 0 ;
SWIG_check_num_args("lldb::SBQueue::SBQueue",0,0)
result = (lldb::SBQueue *)new lldb::SBQueue();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBQueue,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBQueue__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::QueueSP *arg1 = 0 ;
lldb::SBQueue *result = 0 ;
SWIG_check_num_args("lldb::SBQueue::SBQueue",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBQueue::SBQueue",1,"lldb::QueueSP const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__shared_ptrT_lldb_private__Queue_t,0))){
SWIG_fail_ptr("new_SBQueue",1,SWIGTYPE_p_std__shared_ptrT_lldb_private__Queue_t);
}
result = (lldb::SBQueue *)new lldb::SBQueue((lldb::QueueSP const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBQueue,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBQueue(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBQueue__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__shared_ptrT_lldb_private__Queue_t, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBQueue__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBQueue'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBQueue::SBQueue()\n"
" lldb::SBQueue::SBQueue(lldb::QueueSP const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBQueue_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBQueue::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::IsValid",1,"lldb::SBQueue const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){
SWIG_fail_ptr("SBQueue_IsValid",1,SWIGTYPE_p_lldb__SBQueue);
}
result = (bool)((lldb::SBQueue const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBQueue_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ;
SWIG_check_num_args("lldb::SBQueue::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::Clear",1,"lldb::SBQueue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){
SWIG_fail_ptr("SBQueue_Clear",1,SWIGTYPE_p_lldb__SBQueue);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBQueue_GetProcess(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ;
lldb::SBProcess result;
SWIG_check_num_args("lldb::SBQueue::GetProcess",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetProcess",1,"lldb::SBQueue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){
SWIG_fail_ptr("SBQueue_GetProcess",1,SWIGTYPE_p_lldb__SBQueue);
}
result = (arg1)->GetProcess();
{
lldb::SBProcess * resultptr = new lldb::SBProcess((const lldb::SBProcess &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBQueue_GetQueueID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ;
lldb::queue_id_t result;
SWIG_check_num_args("lldb::SBQueue::GetQueueID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetQueueID",1,"lldb::SBQueue const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){
SWIG_fail_ptr("SBQueue_GetQueueID",1,SWIGTYPE_p_lldb__SBQueue);
}
result = (lldb::queue_id_t)((lldb::SBQueue const *)arg1)->GetQueueID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBQueue_GetName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBQueue::GetName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetName",1,"lldb::SBQueue const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){
SWIG_fail_ptr("SBQueue_GetName",1,SWIGTYPE_p_lldb__SBQueue);
}
result = (char *)((lldb::SBQueue const *)arg1)->GetName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBQueue_GetKind(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ;
lldb::QueueKind result;
SWIG_check_num_args("lldb::SBQueue::GetKind",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetKind",1,"lldb::SBQueue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){
SWIG_fail_ptr("SBQueue_GetKind",1,SWIGTYPE_p_lldb__SBQueue);
}
result = (lldb::QueueKind)(arg1)->GetKind();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBQueue_GetIndexID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBQueue::GetIndexID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetIndexID",1,"lldb::SBQueue const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){
SWIG_fail_ptr("SBQueue_GetIndexID",1,SWIGTYPE_p_lldb__SBQueue);
}
result = (uint32_t)((lldb::SBQueue const *)arg1)->GetIndexID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBQueue_GetNumThreads(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBQueue::GetNumThreads",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetNumThreads",1,"lldb::SBQueue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){
SWIG_fail_ptr("SBQueue_GetNumThreads",1,SWIGTYPE_p_lldb__SBQueue);
}
result = (uint32_t)(arg1)->GetNumThreads();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBQueue_GetThreadAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ;
uint32_t arg2 ;
lldb::SBThread result;
SWIG_check_num_args("lldb::SBQueue::GetThreadAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetThreadAtIndex",1,"lldb::SBQueue *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBQueue::GetThreadAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){
SWIG_fail_ptr("SBQueue_GetThreadAtIndex",1,SWIGTYPE_p_lldb__SBQueue);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetThreadAtIndex(arg2);
{
lldb::SBThread * resultptr = new lldb::SBThread((const lldb::SBThread &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBQueue_GetNumPendingItems(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBQueue::GetNumPendingItems",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetNumPendingItems",1,"lldb::SBQueue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){
SWIG_fail_ptr("SBQueue_GetNumPendingItems",1,SWIGTYPE_p_lldb__SBQueue);
}
result = (uint32_t)(arg1)->GetNumPendingItems();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBQueue_GetPendingItemAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ;
uint32_t arg2 ;
lldb::SBQueueItem result;
SWIG_check_num_args("lldb::SBQueue::GetPendingItemAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetPendingItemAtIndex",1,"lldb::SBQueue *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBQueue::GetPendingItemAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){
SWIG_fail_ptr("SBQueue_GetPendingItemAtIndex",1,SWIGTYPE_p_lldb__SBQueue);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetPendingItemAtIndex(arg2);
{
lldb::SBQueueItem * resultptr = new lldb::SBQueueItem((const lldb::SBQueueItem &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBQueueItem,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBQueue_GetNumRunningItems(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBQueue::GetNumRunningItems",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetNumRunningItems",1,"lldb::SBQueue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){
SWIG_fail_ptr("SBQueue_GetNumRunningItems",1,SWIGTYPE_p_lldb__SBQueue);
}
result = (uint32_t)(arg1)->GetNumRunningItems();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBQueue(void *obj) {
lldb::SBQueue *arg1 = (lldb::SBQueue *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBQueue(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBQueue);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBQueue_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBQueue_methods[]= {
{ "IsValid", _wrap_SBQueue_IsValid},
{ "Clear", _wrap_SBQueue_Clear},
{ "GetProcess", _wrap_SBQueue_GetProcess},
{ "GetQueueID", _wrap_SBQueue_GetQueueID},
{ "GetName", _wrap_SBQueue_GetName},
{ "GetKind", _wrap_SBQueue_GetKind},
{ "GetIndexID", _wrap_SBQueue_GetIndexID},
{ "GetNumThreads", _wrap_SBQueue_GetNumThreads},
{ "GetThreadAtIndex", _wrap_SBQueue_GetThreadAtIndex},
{ "GetNumPendingItems", _wrap_SBQueue_GetNumPendingItems},
{ "GetPendingItemAtIndex", _wrap_SBQueue_GetPendingItemAtIndex},
{ "GetNumRunningItems", _wrap_SBQueue_GetNumRunningItems},
{0,0}
};
static swig_lua_method swig_SBQueue_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBQueue_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBQueue_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBQueue_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBQueue_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBQueue_Sf_SwigStatic = {
"SBQueue",
swig_SBQueue_Sf_SwigStatic_methods,
swig_SBQueue_Sf_SwigStatic_attributes,
swig_SBQueue_Sf_SwigStatic_constants,
swig_SBQueue_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBQueue_bases[] = {0};
static const char *swig_SBQueue_base_names[] = {0};
static swig_lua_class _wrap_class_SBQueue = { "SBQueue", "SBQueue", &SWIGTYPE_p_lldb__SBQueue,_proxy__wrap_new_SBQueue, swig_delete_SBQueue, swig_SBQueue_methods, swig_SBQueue_attributes, &swig_SBQueue_Sf_SwigStatic, swig_SBQueue_meta, swig_SBQueue_bases, swig_SBQueue_base_names };
static int _wrap_new_SBQueueItem__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueueItem *result = 0 ;
SWIG_check_num_args("lldb::SBQueueItem::SBQueueItem",0,0)
result = (lldb::SBQueueItem *)new lldb::SBQueueItem();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBQueueItem,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBQueueItem__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::QueueItemSP *arg1 = 0 ;
lldb::SBQueueItem *result = 0 ;
SWIG_check_num_args("lldb::SBQueueItem::SBQueueItem",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBQueueItem::SBQueueItem",1,"lldb::QueueItemSP const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__shared_ptrT_lldb_private__QueueItem_t,0))){
SWIG_fail_ptr("new_SBQueueItem",1,SWIGTYPE_p_std__shared_ptrT_lldb_private__QueueItem_t);
}
result = (lldb::SBQueueItem *)new lldb::SBQueueItem((lldb::QueueItemSP const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBQueueItem,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBQueueItem(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBQueueItem__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__shared_ptrT_lldb_private__QueueItem_t, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBQueueItem__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBQueueItem'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBQueueItem::SBQueueItem()\n"
" lldb::SBQueueItem::SBQueueItem(lldb::QueueItemSP const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBQueueItem_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBQueueItem::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueueItem::IsValid",1,"lldb::SBQueueItem const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueueItem,0))){
SWIG_fail_ptr("SBQueueItem_IsValid",1,SWIGTYPE_p_lldb__SBQueueItem);
}
result = (bool)((lldb::SBQueueItem const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBQueueItem_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ;
SWIG_check_num_args("lldb::SBQueueItem::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueueItem::Clear",1,"lldb::SBQueueItem *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueueItem,0))){
SWIG_fail_ptr("SBQueueItem_Clear",1,SWIGTYPE_p_lldb__SBQueueItem);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBQueueItem_GetKind(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ;
lldb::QueueItemKind result;
SWIG_check_num_args("lldb::SBQueueItem::GetKind",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueueItem::GetKind",1,"lldb::SBQueueItem const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueueItem,0))){
SWIG_fail_ptr("SBQueueItem_GetKind",1,SWIGTYPE_p_lldb__SBQueueItem);
}
result = (lldb::QueueItemKind)((lldb::SBQueueItem const *)arg1)->GetKind();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBQueueItem_SetKind(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ;
lldb::QueueItemKind arg2 ;
SWIG_check_num_args("lldb::SBQueueItem::SetKind",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueueItem::SetKind",1,"lldb::SBQueueItem *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBQueueItem::SetKind",2,"lldb::QueueItemKind");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueueItem,0))){
SWIG_fail_ptr("SBQueueItem_SetKind",1,SWIGTYPE_p_lldb__SBQueueItem);
}
arg2 = (lldb::QueueItemKind)lua_tointeger(L, 2);
(arg1)->SetKind(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBQueueItem_GetAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBQueueItem::GetAddress",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueueItem::GetAddress",1,"lldb::SBQueueItem const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueueItem,0))){
SWIG_fail_ptr("SBQueueItem_GetAddress",1,SWIGTYPE_p_lldb__SBQueueItem);
}
result = ((lldb::SBQueueItem const *)arg1)->GetAddress();
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBQueueItem_SetAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ;
lldb::SBAddress arg2 ;
lldb::SBAddress *argp2 ;
SWIG_check_num_args("lldb::SBQueueItem::SetAddress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueueItem::SetAddress",1,"lldb::SBQueueItem *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBQueueItem::SetAddress",2,"lldb::SBAddress");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueueItem,0))){
SWIG_fail_ptr("SBQueueItem_SetAddress",1,SWIGTYPE_p_lldb__SBQueueItem);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBQueueItem_SetAddress",2,SWIGTYPE_p_lldb__SBAddress);
}
arg2 = *argp2;
(arg1)->SetAddress(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBQueueItem_SetQueueItem(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ;
lldb::QueueItemSP *arg2 = 0 ;
SWIG_check_num_args("lldb::SBQueueItem::SetQueueItem",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueueItem::SetQueueItem",1,"lldb::SBQueueItem *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBQueueItem::SetQueueItem",2,"lldb::QueueItemSP const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueueItem,0))){
SWIG_fail_ptr("SBQueueItem_SetQueueItem",1,SWIGTYPE_p_lldb__SBQueueItem);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__shared_ptrT_lldb_private__QueueItem_t,0))){
SWIG_fail_ptr("SBQueueItem_SetQueueItem",2,SWIGTYPE_p_std__shared_ptrT_lldb_private__QueueItem_t);
}
(arg1)->SetQueueItem((lldb::QueueItemSP const &)*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBQueueItem_GetExtendedBacktraceThread(lua_State* L) {
int SWIG_arg = 0;
lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBThread result;
SWIG_check_num_args("lldb::SBQueueItem::GetExtendedBacktraceThread",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueueItem::GetExtendedBacktraceThread",1,"lldb::SBQueueItem *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBQueueItem::GetExtendedBacktraceThread",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueueItem,0))){
SWIG_fail_ptr("SBQueueItem_GetExtendedBacktraceThread",1,SWIGTYPE_p_lldb__SBQueueItem);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->GetExtendedBacktraceThread((char const *)arg2);
{
lldb::SBThread * resultptr = new lldb::SBThread((const lldb::SBThread &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBQueueItem(void *obj) {
lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBQueueItem(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBQueueItem);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBQueueItem_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBQueueItem_methods[]= {
{ "IsValid", _wrap_SBQueueItem_IsValid},
{ "Clear", _wrap_SBQueueItem_Clear},
{ "GetKind", _wrap_SBQueueItem_GetKind},
{ "SetKind", _wrap_SBQueueItem_SetKind},
{ "GetAddress", _wrap_SBQueueItem_GetAddress},
{ "SetAddress", _wrap_SBQueueItem_SetAddress},
{ "SetQueueItem", _wrap_SBQueueItem_SetQueueItem},
{ "GetExtendedBacktraceThread", _wrap_SBQueueItem_GetExtendedBacktraceThread},
{0,0}
};
static swig_lua_method swig_SBQueueItem_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBQueueItem_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBQueueItem_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBQueueItem_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBQueueItem_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBQueueItem_Sf_SwigStatic = {
"SBQueueItem",
swig_SBQueueItem_Sf_SwigStatic_methods,
swig_SBQueueItem_Sf_SwigStatic_attributes,
swig_SBQueueItem_Sf_SwigStatic_constants,
swig_SBQueueItem_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBQueueItem_bases[] = {0};
static const char *swig_SBQueueItem_base_names[] = {0};
static swig_lua_class _wrap_class_SBQueueItem = { "SBQueueItem", "SBQueueItem", &SWIGTYPE_p_lldb__SBQueueItem,_proxy__wrap_new_SBQueueItem, swig_delete_SBQueueItem, swig_SBQueueItem_methods, swig_SBQueueItem_attributes, &swig_SBQueueItem_Sf_SwigStatic, swig_SBQueueItem_meta, swig_SBQueueItem_bases, swig_SBQueueItem_base_names };
static int _wrap_SBReproducer_Capture(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBReproducer::Capture",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBReproducer::Capture",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = (char *)lldb::SBReproducer::Capture((char const *)arg1);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBReproducer_PassiveReplay(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBReproducer::PassiveReplay",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBReproducer::PassiveReplay",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = (char *)lldb::SBReproducer::PassiveReplay((char const *)arg1);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBReproducer_SetAutoGenerate(lua_State* L) {
int SWIG_arg = 0;
bool arg1 ;
bool result;
SWIG_check_num_args("lldb::SBReproducer::SetAutoGenerate",1,1)
if(!lua_isboolean(L,1)) SWIG_fail_arg("lldb::SBReproducer::SetAutoGenerate",1,"bool");
arg1 = (lua_toboolean(L, 1)!=0);
result = (bool)lldb::SBReproducer::SetAutoGenerate(arg1);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBReproducer_SetWorkingDirectory(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
SWIG_check_num_args("lldb::SBReproducer::SetWorkingDirectory",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBReproducer::SetWorkingDirectory",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
lldb::SBReproducer::SetWorkingDirectory((char const *)arg1);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBReproducer(lua_State* L) {
int SWIG_arg = 0;
lldb::SBReproducer *result = 0 ;
SWIG_check_num_args("lldb::SBReproducer::SBReproducer",0,0)
result = (lldb::SBReproducer *)new lldb::SBReproducer();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBReproducer,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBReproducer(void *obj) {
lldb::SBReproducer *arg1 = (lldb::SBReproducer *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBReproducer(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBReproducer);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBReproducer_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBReproducer_methods[]= {
{0,0}
};
static swig_lua_method swig_SBReproducer_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBReproducer_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBReproducer_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBReproducer_Sf_SwigStatic_methods[]= {
{ "Capture", _wrap_SBReproducer_Capture},
{ "PassiveReplay", _wrap_SBReproducer_PassiveReplay},
{ "SetAutoGenerate", _wrap_SBReproducer_SetAutoGenerate},
{ "SetWorkingDirectory", _wrap_SBReproducer_SetWorkingDirectory},
{0,0}
};
static swig_lua_class* swig_SBReproducer_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBReproducer_Sf_SwigStatic = {
"SBReproducer",
swig_SBReproducer_Sf_SwigStatic_methods,
swig_SBReproducer_Sf_SwigStatic_attributes,
swig_SBReproducer_Sf_SwigStatic_constants,
swig_SBReproducer_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBReproducer_bases[] = {0};
static const char *swig_SBReproducer_base_names[] = {0};
static swig_lua_class _wrap_class_SBReproducer = { "SBReproducer", "SBReproducer", &SWIGTYPE_p_lldb__SBReproducer,_proxy__wrap_new_SBReproducer, swig_delete_SBReproducer, swig_SBReproducer_methods, swig_SBReproducer_attributes, &swig_SBReproducer_Sf_SwigStatic, swig_SBReproducer_meta, swig_SBReproducer_bases, swig_SBReproducer_base_names };
static int _wrap_new_SBSection__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *result = 0 ;
SWIG_check_num_args("lldb::SBSection::SBSection",0,0)
result = (lldb::SBSection *)new lldb::SBSection();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSection,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBSection__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = 0 ;
lldb::SBSection *result = 0 ;
SWIG_check_num_args("lldb::SBSection::SBSection",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBSection::SBSection",1,"lldb::SBSection const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("new_SBSection",1,SWIGTYPE_p_lldb__SBSection);
}
result = (lldb::SBSection *)new lldb::SBSection((lldb::SBSection const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSection,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBSection(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBSection__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSection, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBSection__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBSection'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBSection::SBSection()\n"
" lldb::SBSection::SBSection(lldb::SBSection const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBSection_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBSection::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::IsValid",1,"lldb::SBSection const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection_IsValid",1,SWIGTYPE_p_lldb__SBSection);
}
result = (bool)((lldb::SBSection const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSection_GetName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBSection::GetName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetName",1,"lldb::SBSection *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection_GetName",1,SWIGTYPE_p_lldb__SBSection);
}
result = (char *)(arg1)->GetName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSection_GetParent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
lldb::SBSection result;
SWIG_check_num_args("lldb::SBSection::GetParent",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetParent",1,"lldb::SBSection *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection_GetParent",1,SWIGTYPE_p_lldb__SBSection);
}
result = (arg1)->GetParent();
{
lldb::SBSection * resultptr = new lldb::SBSection((const lldb::SBSection &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSection,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSection_FindSubSection(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBSection result;
SWIG_check_num_args("lldb::SBSection::FindSubSection",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::FindSubSection",1,"lldb::SBSection *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBSection::FindSubSection",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection_FindSubSection",1,SWIGTYPE_p_lldb__SBSection);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->FindSubSection((char const *)arg2);
{
lldb::SBSection * resultptr = new lldb::SBSection((const lldb::SBSection &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSection,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSection_GetNumSubSections(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBSection::GetNumSubSections",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetNumSubSections",1,"lldb::SBSection *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection_GetNumSubSections",1,SWIGTYPE_p_lldb__SBSection);
}
result = (arg1)->GetNumSubSections();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSection_GetSubSectionAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
size_t arg2 ;
lldb::SBSection result;
SWIG_check_num_args("lldb::SBSection::GetSubSectionAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetSubSectionAtIndex",1,"lldb::SBSection *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBSection::GetSubSectionAtIndex",2,"size_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection_GetSubSectionAtIndex",1,SWIGTYPE_p_lldb__SBSection);
}
arg2 = (size_t)lua_tointeger(L, 2);
result = (arg1)->GetSubSectionAtIndex(arg2);
{
lldb::SBSection * resultptr = new lldb::SBSection((const lldb::SBSection &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSection,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSection_GetFileAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBSection::GetFileAddress",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetFileAddress",1,"lldb::SBSection *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection_GetFileAddress",1,SWIGTYPE_p_lldb__SBSection);
}
result = (lldb::addr_t)(arg1)->GetFileAddress();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSection_GetLoadAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
lldb::SBTarget *arg2 = 0 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBSection::GetLoadAddress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetLoadAddress",1,"lldb::SBSection *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSection::GetLoadAddress",2,"lldb::SBTarget &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection_GetLoadAddress",1,SWIGTYPE_p_lldb__SBSection);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBSection_GetLoadAddress",2,SWIGTYPE_p_lldb__SBTarget);
}
result = (lldb::addr_t)(arg1)->GetLoadAddress(*arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSection_GetByteSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBSection::GetByteSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetByteSize",1,"lldb::SBSection *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection_GetByteSize",1,SWIGTYPE_p_lldb__SBSection);
}
result = (lldb::addr_t)(arg1)->GetByteSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSection_GetFileOffset(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
uint64_t result;
SWIG_check_num_args("lldb::SBSection::GetFileOffset",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetFileOffset",1,"lldb::SBSection *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection_GetFileOffset",1,SWIGTYPE_p_lldb__SBSection);
}
result = (uint64_t)(arg1)->GetFileOffset();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSection_GetFileByteSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
uint64_t result;
SWIG_check_num_args("lldb::SBSection::GetFileByteSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetFileByteSize",1,"lldb::SBSection *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection_GetFileByteSize",1,SWIGTYPE_p_lldb__SBSection);
}
result = (uint64_t)(arg1)->GetFileByteSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSection_GetSectionData__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
lldb::SBData result;
SWIG_check_num_args("lldb::SBSection::GetSectionData",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetSectionData",1,"lldb::SBSection *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection_GetSectionData",1,SWIGTYPE_p_lldb__SBSection);
}
result = (arg1)->GetSectionData();
{
lldb::SBData * resultptr = new lldb::SBData((const lldb::SBData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSection_GetSectionData__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
uint64_t arg2 ;
uint64_t arg3 ;
lldb::SBData result;
SWIG_check_num_args("lldb::SBSection::GetSectionData",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetSectionData",1,"lldb::SBSection *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBSection::GetSectionData",2,"uint64_t");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBSection::GetSectionData",3,"uint64_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection_GetSectionData",1,SWIGTYPE_p_lldb__SBSection);
}
arg2 = (uint64_t)lua_tointeger(L, 2);
arg3 = (uint64_t)lua_tointeger(L, 3);
result = (arg1)->GetSectionData(arg2,arg3);
{
lldb::SBData * resultptr = new lldb::SBData((const lldb::SBData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSection_GetSectionData(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSection, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBSection_GetSectionData__SWIG_0(L);
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSection, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBSection_GetSectionData__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBSection_GetSectionData'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBSection::GetSectionData()\n"
" lldb::SBSection::GetSectionData(uint64_t,uint64_t)\n");
lua_error(L);return 0;
}
static int _wrap_SBSection_GetSectionType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
lldb::SectionType result;
SWIG_check_num_args("lldb::SBSection::GetSectionType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetSectionType",1,"lldb::SBSection *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection_GetSectionType",1,SWIGTYPE_p_lldb__SBSection);
}
result = (lldb::SectionType)(arg1)->GetSectionType();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSection_GetPermissions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBSection::GetPermissions",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetPermissions",1,"lldb::SBSection const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection_GetPermissions",1,SWIGTYPE_p_lldb__SBSection);
}
result = (uint32_t)((lldb::SBSection const *)arg1)->GetPermissions();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSection_GetTargetByteSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBSection::GetTargetByteSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetTargetByteSize",1,"lldb::SBSection *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection_GetTargetByteSize",1,SWIGTYPE_p_lldb__SBSection);
}
result = (uint32_t)(arg1)->GetTargetByteSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSection_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBSection::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetDescription",1,"lldb::SBSection *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSection::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection_GetDescription",1,SWIGTYPE_p_lldb__SBSection);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBSection_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSection___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
lldb::SBSection *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBSection::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::operator ==",1,"lldb::SBSection *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSection::operator ==",2,"lldb::SBSection const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection___eq",1,SWIGTYPE_p_lldb__SBSection);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection___eq",2,SWIGTYPE_p_lldb__SBSection);
}
result = (bool)(arg1)->operator ==((lldb::SBSection const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSection___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSection *arg1 = (lldb::SBSection *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBSection::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::__str__",1,"lldb::SBSection *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBSection___tostring",1,SWIGTYPE_p_lldb__SBSection);
}
result = lldb_SBSection___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBSection(void *obj) {
lldb::SBSection *arg1 = (lldb::SBSection *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBSection(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBSection);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBSection_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBSection_methods[]= {
{ "IsValid", _wrap_SBSection_IsValid},
{ "GetName", _wrap_SBSection_GetName},
{ "GetParent", _wrap_SBSection_GetParent},
{ "FindSubSection", _wrap_SBSection_FindSubSection},
{ "GetNumSubSections", _wrap_SBSection_GetNumSubSections},
{ "GetSubSectionAtIndex", _wrap_SBSection_GetSubSectionAtIndex},
{ "GetFileAddress", _wrap_SBSection_GetFileAddress},
{ "GetLoadAddress", _wrap_SBSection_GetLoadAddress},
{ "GetByteSize", _wrap_SBSection_GetByteSize},
{ "GetFileOffset", _wrap_SBSection_GetFileOffset},
{ "GetFileByteSize", _wrap_SBSection_GetFileByteSize},
{ "GetSectionData", _wrap_SBSection_GetSectionData},
{ "GetSectionType", _wrap_SBSection_GetSectionType},
{ "GetPermissions", _wrap_SBSection_GetPermissions},
{ "GetTargetByteSize", _wrap_SBSection_GetTargetByteSize},
{ "GetDescription", _wrap_SBSection_GetDescription},
{ "__eq", _wrap_SBSection___eq},
{ "__tostring", _wrap_SBSection___tostring},
{0,0}
};
static swig_lua_method swig_SBSection_meta[] = {
{ "__eq", _wrap_SBSection___eq},
{ "__tostring", _wrap_SBSection___tostring},
{0,0}
};
static swig_lua_attribute swig_SBSection_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBSection_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBSection_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBSection_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBSection_Sf_SwigStatic = {
"SBSection",
swig_SBSection_Sf_SwigStatic_methods,
swig_SBSection_Sf_SwigStatic_attributes,
swig_SBSection_Sf_SwigStatic_constants,
swig_SBSection_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBSection_bases[] = {0};
static const char *swig_SBSection_base_names[] = {0};
static swig_lua_class _wrap_class_SBSection = { "SBSection", "SBSection", &SWIGTYPE_p_lldb__SBSection,_proxy__wrap_new_SBSection, swig_delete_SBSection, swig_SBSection_methods, swig_SBSection_attributes, &swig_SBSection_Sf_SwigStatic, swig_SBSection_meta, swig_SBSection_bases, swig_SBSection_base_names };
static int _wrap_new_SBSourceManager(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSourceManager *arg1 = 0 ;
lldb::SBSourceManager *result = 0 ;
SWIG_check_num_args("lldb::SBSourceManager::SBSourceManager",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBSourceManager::SBSourceManager",1,"lldb::SBSourceManager const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSourceManager,0))){
SWIG_fail_ptr("new_SBSourceManager",1,SWIGTYPE_p_lldb__SBSourceManager);
}
result = (lldb::SBSourceManager *)new lldb::SBSourceManager((lldb::SBSourceManager const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSourceManager,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSourceManager_DisplaySourceLinesWithLineNumbers(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSourceManager *arg1 = (lldb::SBSourceManager *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
uint32_t arg3 ;
uint32_t arg4 ;
uint32_t arg5 ;
char *arg6 = (char *) 0 ;
lldb::SBStream *arg7 = 0 ;
size_t result;
SWIG_check_num_args("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbers",7,7)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbers",1,"lldb::SBSourceManager *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbers",2,"lldb::SBFileSpec const &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbers",3,"uint32_t");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbers",4,"uint32_t");
if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbers",5,"uint32_t");
if(!SWIG_lua_isnilstring(L,6)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbers",6,"char const *");
if(!lua_isuserdata(L,7)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbers",7,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSourceManager,0))){
SWIG_fail_ptr("SBSourceManager_DisplaySourceLinesWithLineNumbers",1,SWIGTYPE_p_lldb__SBSourceManager);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBSourceManager_DisplaySourceLinesWithLineNumbers",2,SWIGTYPE_p_lldb__SBFileSpec);
}
arg3 = (uint32_t)lua_tointeger(L, 3);
arg4 = (uint32_t)lua_tointeger(L, 4);
arg5 = (uint32_t)lua_tointeger(L, 5);
arg6 = (char *)lua_tostring(L, 6);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBSourceManager_DisplaySourceLinesWithLineNumbers",7,SWIGTYPE_p_lldb__SBStream);
}
result = (arg1)->DisplaySourceLinesWithLineNumbers((lldb::SBFileSpec const &)*arg2,arg3,arg4,arg5,(char const *)arg6,*arg7);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSourceManager *arg1 = (lldb::SBSourceManager *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
uint32_t arg3 ;
uint32_t arg4 ;
uint32_t arg5 ;
uint32_t arg6 ;
char *arg7 = (char *) 0 ;
lldb::SBStream *arg8 = 0 ;
size_t result;
SWIG_check_num_args("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn",8,8)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn",1,"lldb::SBSourceManager *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn",2,"lldb::SBFileSpec const &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn",3,"uint32_t");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn",4,"uint32_t");
if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn",5,"uint32_t");
if(!lua_isinteger(L,6)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn",6,"uint32_t");
if(!SWIG_lua_isnilstring(L,7)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn",7,"char const *");
if(!lua_isuserdata(L,8)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn",8,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSourceManager,0))){
SWIG_fail_ptr("SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn",1,SWIGTYPE_p_lldb__SBSourceManager);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn",2,SWIGTYPE_p_lldb__SBFileSpec);
}
arg3 = (uint32_t)lua_tointeger(L, 3);
arg4 = (uint32_t)lua_tointeger(L, 4);
arg5 = (uint32_t)lua_tointeger(L, 5);
arg6 = (uint32_t)lua_tointeger(L, 6);
arg7 = (char *)lua_tostring(L, 7);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,8,(void**)&arg8,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn",8,SWIGTYPE_p_lldb__SBStream);
}
result = (arg1)->DisplaySourceLinesWithLineNumbersAndColumn((lldb::SBFileSpec const &)*arg2,arg3,arg4,arg5,arg6,(char const *)arg7,*arg8);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBSourceManager(void *obj) {
lldb::SBSourceManager *arg1 = (lldb::SBSourceManager *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBSourceManager(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBSourceManager);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBSourceManager_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBSourceManager_methods[]= {
{ "DisplaySourceLinesWithLineNumbers", _wrap_SBSourceManager_DisplaySourceLinesWithLineNumbers},
{ "DisplaySourceLinesWithLineNumbersAndColumn", _wrap_SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn},
{0,0}
};
static swig_lua_method swig_SBSourceManager_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBSourceManager_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBSourceManager_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBSourceManager_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBSourceManager_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBSourceManager_Sf_SwigStatic = {
"SBSourceManager",
swig_SBSourceManager_Sf_SwigStatic_methods,
swig_SBSourceManager_Sf_SwigStatic_attributes,
swig_SBSourceManager_Sf_SwigStatic_constants,
swig_SBSourceManager_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBSourceManager_bases[] = {0};
static const char *swig_SBSourceManager_base_names[] = {0};
static swig_lua_class _wrap_class_SBSourceManager = { "SBSourceManager", "SBSourceManager", &SWIGTYPE_p_lldb__SBSourceManager,_proxy__wrap_new_SBSourceManager, swig_delete_SBSourceManager, swig_SBSourceManager_methods, swig_SBSourceManager_attributes, &swig_SBSourceManager_Sf_SwigStatic, swig_SBSourceManager_meta, swig_SBSourceManager_bases, swig_SBSourceManager_base_names };
static int _wrap_new_SBStream(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStream *result = 0 ;
SWIG_check_num_args("lldb::SBStream::SBStream",0,0)
result = (lldb::SBStream *)new lldb::SBStream();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBStream,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStream_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStream *arg1 = (lldb::SBStream *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBStream::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::IsValid",1,"lldb::SBStream const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBStream_IsValid",1,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)((lldb::SBStream const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStream_GetData(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStream *arg1 = (lldb::SBStream *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBStream::GetData",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::GetData",1,"lldb::SBStream *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBStream_GetData",1,SWIGTYPE_p_lldb__SBStream);
}
result = (char *)(arg1)->GetData();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStream_GetSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStream *arg1 = (lldb::SBStream *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBStream::GetSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::GetSize",1,"lldb::SBStream *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBStream_GetSize",1,SWIGTYPE_p_lldb__SBStream);
}
result = (arg1)->GetSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStream_Print(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStream *arg1 = (lldb::SBStream *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBStream::Print",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::Print",1,"lldb::SBStream *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBStream::Print",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBStream_Print",1,SWIGTYPE_p_lldb__SBStream);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->Print((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStream_RedirectToFile__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStream *arg1 = (lldb::SBStream *) 0 ;
char *arg2 = (char *) 0 ;
bool arg3 ;
SWIG_check_num_args("lldb::SBStream::RedirectToFile",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::RedirectToFile",1,"lldb::SBStream *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBStream::RedirectToFile",2,"char const *");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBStream::RedirectToFile",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBStream_RedirectToFile",1,SWIGTYPE_p_lldb__SBStream);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (lua_toboolean(L, 3)!=0);
(arg1)->RedirectToFile((char const *)arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStream_RedirectToFile__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStream *arg1 = (lldb::SBStream *) 0 ;
lldb::SBFile arg2 ;
lldb::SBFile *argp2 ;
SWIG_check_num_args("lldb::SBStream::RedirectToFile",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::RedirectToFile",1,"lldb::SBStream *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBStream::RedirectToFile",2,"lldb::SBFile");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBStream_RedirectToFile",1,SWIGTYPE_p_lldb__SBStream);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){
SWIG_fail_ptr("SBStream_RedirectToFile",2,SWIGTYPE_p_lldb__SBFile);
}
arg2 = *argp2;
(arg1)->RedirectToFile(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStream_RedirectToFile__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStream *arg1 = (lldb::SBStream *) 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
SWIG_check_num_args("lldb::SBStream::RedirectToFile",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::RedirectToFile",1,"lldb::SBStream *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBStream_RedirectToFile",1,SWIGTYPE_p_lldb__SBStream);
}
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg2 = file_sp;
}
(arg1)->RedirectToFile(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStream_RedirectToFile(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBStream_RedirectToFile__SWIG_1(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_isuserdata(L, argv[1])) &&
(luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr);
}
if (_v) {
return _wrap_SBStream_RedirectToFile__SWIG_2(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[2]);
}
if (_v) {
return _wrap_SBStream_RedirectToFile__SWIG_0(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBStream_RedirectToFile'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBStream::RedirectToFile(char const *,bool)\n"
" lldb::SBStream::RedirectToFile(lldb::SBFile)\n"
" lldb::SBStream::RedirectToFile(lldb::FileSP)\n");
lua_error(L);return 0;
}
static int _wrap_SBStream_RedirectToFileHandle(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStream *arg1 = (lldb::SBStream *) 0 ;
SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
bool arg3 ;
SWIG_check_num_args("lldb::SBStream::RedirectToFileHandle",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::RedirectToFileHandle",1,"lldb::SBStream *");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBStream::RedirectToFileHandle",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBStream_RedirectToFileHandle",1,SWIGTYPE_p_lldb__SBStream);
}
{
luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE);
lldb::FileSP file_sp;
file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
if (!file_sp->IsValid())
return luaL_error(L, "Invalid file");
arg2 = file_sp;
}
arg3 = (lua_toboolean(L, 3)!=0);
lldb_SBStream_RedirectToFileHandle(arg1,arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStream_RedirectToFileDescriptor(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStream *arg1 = (lldb::SBStream *) 0 ;
int arg2 ;
bool arg3 ;
SWIG_check_num_args("lldb::SBStream::RedirectToFileDescriptor",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::RedirectToFileDescriptor",1,"lldb::SBStream *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBStream::RedirectToFileDescriptor",2,"int");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBStream::RedirectToFileDescriptor",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBStream_RedirectToFileDescriptor",1,SWIGTYPE_p_lldb__SBStream);
}
arg2 = (int)lua_tointeger(L, 2);
arg3 = (lua_toboolean(L, 3)!=0);
(arg1)->RedirectToFileDescriptor(arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStream_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStream *arg1 = (lldb::SBStream *) 0 ;
SWIG_check_num_args("lldb::SBStream::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::Clear",1,"lldb::SBStream *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBStream_Clear",1,SWIGTYPE_p_lldb__SBStream);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBStream(void *obj) {
lldb::SBStream *arg1 = (lldb::SBStream *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBStream(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBStream);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBStream_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBStream_methods[]= {
{ "IsValid", _wrap_SBStream_IsValid},
{ "GetData", _wrap_SBStream_GetData},
{ "GetSize", _wrap_SBStream_GetSize},
{ "Print", _wrap_SBStream_Print},
{ "RedirectToFile", _wrap_SBStream_RedirectToFile},
{ "RedirectToFileHandle", _wrap_SBStream_RedirectToFileHandle},
{ "RedirectToFileDescriptor", _wrap_SBStream_RedirectToFileDescriptor},
{ "Clear", _wrap_SBStream_Clear},
{0,0}
};
static swig_lua_method swig_SBStream_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBStream_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBStream_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBStream_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBStream_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBStream_Sf_SwigStatic = {
"SBStream",
swig_SBStream_Sf_SwigStatic_methods,
swig_SBStream_Sf_SwigStatic_attributes,
swig_SBStream_Sf_SwigStatic_constants,
swig_SBStream_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBStream_bases[] = {0};
static const char *swig_SBStream_base_names[] = {0};
static swig_lua_class _wrap_class_SBStream = { "SBStream", "SBStream", &SWIGTYPE_p_lldb__SBStream,_proxy__wrap_new_SBStream, swig_delete_SBStream, swig_SBStream_methods, swig_SBStream_attributes, &swig_SBStream_Sf_SwigStatic, swig_SBStream_meta, swig_SBStream_bases, swig_SBStream_base_names };
static int _wrap_new_SBStringList__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStringList *result = 0 ;
SWIG_check_num_args("lldb::SBStringList::SBStringList",0,0)
result = (lldb::SBStringList *)new lldb::SBStringList();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBStringList,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBStringList__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStringList *arg1 = 0 ;
lldb::SBStringList *result = 0 ;
SWIG_check_num_args("lldb::SBStringList::SBStringList",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBStringList::SBStringList",1,"lldb::SBStringList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("new_SBStringList",1,SWIGTYPE_p_lldb__SBStringList);
}
result = (lldb::SBStringList *)new lldb::SBStringList((lldb::SBStringList const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBStringList,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBStringList(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBStringList__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStringList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBStringList__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBStringList'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBStringList::SBStringList()\n"
" lldb::SBStringList::SBStringList(lldb::SBStringList const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBStringList_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBStringList::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStringList::IsValid",1,"lldb::SBStringList const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBStringList_IsValid",1,SWIGTYPE_p_lldb__SBStringList);
}
result = (bool)((lldb::SBStringList const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStringList_AppendString(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBStringList::AppendString",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStringList::AppendString",1,"lldb::SBStringList *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBStringList::AppendString",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBStringList_AppendString",1,SWIGTYPE_p_lldb__SBStringList);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->AppendString((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStringList_AppendList__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ;
char **arg2 = (char **) 0 ;
int arg3 ;
SWIG_check_num_args("lldb::SBStringList::AppendList",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStringList::AppendList",1,"lldb::SBStringList *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBStringList::AppendList",3,"int");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBStringList_AppendList",1,SWIGTYPE_p_lldb__SBStringList);
}
{
if (lua_istable(L, 2)) {
size_t size = lua_rawlen(L, 2);
arg2 = (char **)malloc((size + 1) * sizeof(char *));
int i = 0, j = 0;
while (i++ < size) {
lua_rawgeti(L, 2, i);
if (!lua_isstring(L, -1)) {
// if current element cannot be converted to string, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain strings");
}
arg2[j++] = (char *)lua_tostring(L, -1);
lua_pop(L, 1);
}
arg2[j] = 0;
} else if (lua_isnil(L, 2)) {
// "nil" is also acceptable, equivalent as an empty table
arg2 = NULL;
} else {
return luaL_error(L, "A list of strings expected");
}
}
arg3 = (int)lua_tointeger(L, 3);
(arg1)->AppendList((char const **)arg2,arg3);
{
free((char *) arg2);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free((char *) arg2);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStringList_AppendList__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ;
lldb::SBStringList *arg2 = 0 ;
SWIG_check_num_args("lldb::SBStringList::AppendList",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStringList::AppendList",1,"lldb::SBStringList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBStringList::AppendList",2,"lldb::SBStringList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBStringList_AppendList",1,SWIGTYPE_p_lldb__SBStringList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBStringList_AppendList",2,SWIGTYPE_p_lldb__SBStringList);
}
(arg1)->AppendList((lldb::SBStringList const &)*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStringList_AppendList(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStringList, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStringList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBStringList_AppendList__SWIG_1(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStringList, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_istable(L, argv[1]) || lua_isnil(L, argv[1]));
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBStringList_AppendList__SWIG_0(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBStringList_AppendList'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBStringList::AppendList(char const **,int)\n"
" lldb::SBStringList::AppendList(lldb::SBStringList const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBStringList_GetSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBStringList::GetSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStringList::GetSize",1,"lldb::SBStringList const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBStringList_GetSize",1,SWIGTYPE_p_lldb__SBStringList);
}
result = (uint32_t)((lldb::SBStringList const *)arg1)->GetSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStringList_GetStringAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ;
size_t arg2 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBStringList::GetStringAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStringList::GetStringAtIndex",1,"lldb::SBStringList *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBStringList::GetStringAtIndex",2,"size_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBStringList_GetStringAtIndex",1,SWIGTYPE_p_lldb__SBStringList);
}
arg2 = (size_t)lua_tointeger(L, 2);
result = (char *)(arg1)->GetStringAtIndex(arg2);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStringList_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ;
SWIG_check_num_args("lldb::SBStringList::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStringList::Clear",1,"lldb::SBStringList *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBStringList_Clear",1,SWIGTYPE_p_lldb__SBStringList);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBStringList(void *obj) {
lldb::SBStringList *arg1 = (lldb::SBStringList *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBStringList(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBStringList);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBStringList_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBStringList_methods[]= {
{ "IsValid", _wrap_SBStringList_IsValid},
{ "AppendString", _wrap_SBStringList_AppendString},
{ "AppendList", _wrap_SBStringList_AppendList},
{ "GetSize", _wrap_SBStringList_GetSize},
{ "GetStringAtIndex", _wrap_SBStringList_GetStringAtIndex},
{ "Clear", _wrap_SBStringList_Clear},
{0,0}
};
static swig_lua_method swig_SBStringList_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBStringList_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBStringList_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBStringList_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBStringList_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBStringList_Sf_SwigStatic = {
"SBStringList",
swig_SBStringList_Sf_SwigStatic_methods,
swig_SBStringList_Sf_SwigStatic_attributes,
swig_SBStringList_Sf_SwigStatic_constants,
swig_SBStringList_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBStringList_bases[] = {0};
static const char *swig_SBStringList_base_names[] = {0};
static swig_lua_class _wrap_class_SBStringList = { "SBStringList", "SBStringList", &SWIGTYPE_p_lldb__SBStringList,_proxy__wrap_new_SBStringList, swig_delete_SBStringList, swig_SBStringList_methods, swig_SBStringList_attributes, &swig_SBStringList_Sf_SwigStatic, swig_SBStringList_meta, swig_SBStringList_bases, swig_SBStringList_base_names };
static int _wrap_new_SBStructuredData__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *result = 0 ;
SWIG_check_num_args("lldb::SBStructuredData::SBStructuredData",0,0)
result = (lldb::SBStructuredData *)new lldb::SBStructuredData();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBStructuredData__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = 0 ;
lldb::SBStructuredData *result = 0 ;
SWIG_check_num_args("lldb::SBStructuredData::SBStructuredData",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBStructuredData::SBStructuredData",1,"lldb::SBStructuredData const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("new_SBStructuredData",1,SWIGTYPE_p_lldb__SBStructuredData);
}
result = (lldb::SBStructuredData *)new lldb::SBStructuredData((lldb::SBStructuredData const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBStructuredData__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::EventSP *arg1 = 0 ;
lldb::SBStructuredData *result = 0 ;
SWIG_check_num_args("lldb::SBStructuredData::SBStructuredData",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBStructuredData::SBStructuredData",1,"lldb::EventSP const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__shared_ptrT_lldb_private__Event_t,0))){
SWIG_fail_ptr("new_SBStructuredData",1,SWIGTYPE_p_std__shared_ptrT_lldb_private__Event_t);
}
result = (lldb::SBStructuredData *)new lldb::SBStructuredData((lldb::EventSP const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBStructuredData(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBStructuredData__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBStructuredData__SWIG_1(L);
}
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__shared_ptrT_lldb_private__Event_t, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBStructuredData__SWIG_2(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBStructuredData'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBStructuredData::SBStructuredData()\n"
" lldb::SBStructuredData::SBStructuredData(lldb::SBStructuredData const &)\n"
" lldb::SBStructuredData::SBStructuredData(lldb::EventSP const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBStructuredData_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBStructuredData::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::IsValid",1,"lldb::SBStructuredData const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBStructuredData_IsValid",1,SWIGTYPE_p_lldb__SBStructuredData);
}
result = (bool)((lldb::SBStructuredData const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStructuredData_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ;
SWIG_check_num_args("lldb::SBStructuredData::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::Clear",1,"lldb::SBStructuredData *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBStructuredData_Clear",1,SWIGTYPE_p_lldb__SBStructuredData);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStructuredData_GetType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ;
lldb::StructuredDataType result;
SWIG_check_num_args("lldb::SBStructuredData::GetType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetType",1,"lldb::SBStructuredData const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBStructuredData_GetType",1,SWIGTYPE_p_lldb__SBStructuredData);
}
result = (lldb::StructuredDataType)((lldb::SBStructuredData const *)arg1)->GetType();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStructuredData_GetSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBStructuredData::GetSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetSize",1,"lldb::SBStructuredData const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBStructuredData_GetSize",1,SWIGTYPE_p_lldb__SBStructuredData);
}
result = ((lldb::SBStructuredData const *)arg1)->GetSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStructuredData_GetKeys(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ;
lldb::SBStringList *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBStructuredData::GetKeys",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetKeys",1,"lldb::SBStructuredData const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBStructuredData::GetKeys",2,"lldb::SBStringList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBStructuredData_GetKeys",1,SWIGTYPE_p_lldb__SBStructuredData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBStructuredData_GetKeys",2,SWIGTYPE_p_lldb__SBStringList);
}
result = (bool)((lldb::SBStructuredData const *)arg1)->GetKeys(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStructuredData_GetValueForKey(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBStructuredData result;
SWIG_check_num_args("lldb::SBStructuredData::GetValueForKey",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetValueForKey",1,"lldb::SBStructuredData const *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBStructuredData::GetValueForKey",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBStructuredData_GetValueForKey",1,SWIGTYPE_p_lldb__SBStructuredData);
}
arg2 = (char *)lua_tostring(L, 2);
result = ((lldb::SBStructuredData const *)arg1)->GetValueForKey((char const *)arg2);
{
lldb::SBStructuredData * resultptr = new lldb::SBStructuredData((const lldb::SBStructuredData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStructuredData_GetItemAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ;
size_t arg2 ;
lldb::SBStructuredData result;
SWIG_check_num_args("lldb::SBStructuredData::GetItemAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetItemAtIndex",1,"lldb::SBStructuredData const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBStructuredData::GetItemAtIndex",2,"size_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBStructuredData_GetItemAtIndex",1,SWIGTYPE_p_lldb__SBStructuredData);
}
arg2 = (size_t)lua_tointeger(L, 2);
result = ((lldb::SBStructuredData const *)arg1)->GetItemAtIndex(arg2);
{
lldb::SBStructuredData * resultptr = new lldb::SBStructuredData((const lldb::SBStructuredData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStructuredData_GetIntegerValue__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ;
uint64_t arg2 ;
uint64_t result;
SWIG_check_num_args("lldb::SBStructuredData::GetIntegerValue",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetIntegerValue",1,"lldb::SBStructuredData const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBStructuredData::GetIntegerValue",2,"uint64_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBStructuredData_GetIntegerValue",1,SWIGTYPE_p_lldb__SBStructuredData);
}
arg2 = (uint64_t)lua_tointeger(L, 2);
result = (uint64_t)((lldb::SBStructuredData const *)arg1)->GetIntegerValue(arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStructuredData_GetIntegerValue__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ;
uint64_t result;
SWIG_check_num_args("lldb::SBStructuredData::GetIntegerValue",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetIntegerValue",1,"lldb::SBStructuredData const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBStructuredData_GetIntegerValue",1,SWIGTYPE_p_lldb__SBStructuredData);
}
result = (uint64_t)((lldb::SBStructuredData const *)arg1)->GetIntegerValue();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStructuredData_GetIntegerValue(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBStructuredData_GetIntegerValue__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBStructuredData_GetIntegerValue__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBStructuredData_GetIntegerValue'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBStructuredData::GetIntegerValue(uint64_t) const\n"
" lldb::SBStructuredData::GetIntegerValue() const\n");
lua_error(L);return 0;
}
static int _wrap_SBStructuredData_GetFloatValue__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ;
double arg2 ;
double result;
SWIG_check_num_args("lldb::SBStructuredData::GetFloatValue",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetFloatValue",1,"lldb::SBStructuredData const *");
if(!lua_isnumber(L,2)) SWIG_fail_arg("lldb::SBStructuredData::GetFloatValue",2,"double");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBStructuredData_GetFloatValue",1,SWIGTYPE_p_lldb__SBStructuredData);
}
arg2 = (double)lua_tonumber(L, 2);
result = (double)((lldb::SBStructuredData const *)arg1)->GetFloatValue(arg2);
lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStructuredData_GetFloatValue__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ;
double result;
SWIG_check_num_args("lldb::SBStructuredData::GetFloatValue",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetFloatValue",1,"lldb::SBStructuredData const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBStructuredData_GetFloatValue",1,SWIGTYPE_p_lldb__SBStructuredData);
}
result = (double)((lldb::SBStructuredData const *)arg1)->GetFloatValue();
lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStructuredData_GetFloatValue(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBStructuredData_GetFloatValue__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBStructuredData_GetFloatValue__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBStructuredData_GetFloatValue'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBStructuredData::GetFloatValue(double) const\n"
" lldb::SBStructuredData::GetFloatValue() const\n");
lua_error(L);return 0;
}
static int _wrap_SBStructuredData_GetBooleanValue__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ;
bool arg2 ;
bool result;
SWIG_check_num_args("lldb::SBStructuredData::GetBooleanValue",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetBooleanValue",1,"lldb::SBStructuredData const *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBStructuredData::GetBooleanValue",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBStructuredData_GetBooleanValue",1,SWIGTYPE_p_lldb__SBStructuredData);
}
arg2 = (lua_toboolean(L, 2)!=0);
result = (bool)((lldb::SBStructuredData const *)arg1)->GetBooleanValue(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStructuredData_GetBooleanValue__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBStructuredData::GetBooleanValue",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetBooleanValue",1,"lldb::SBStructuredData const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBStructuredData_GetBooleanValue",1,SWIGTYPE_p_lldb__SBStructuredData);
}
result = (bool)((lldb::SBStructuredData const *)arg1)->GetBooleanValue();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStructuredData_GetBooleanValue(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBStructuredData_GetBooleanValue__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_SBStructuredData_GetBooleanValue__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBStructuredData_GetBooleanValue'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBStructuredData::GetBooleanValue(bool) const\n"
" lldb::SBStructuredData::GetBooleanValue() const\n");
lua_error(L);return 0;
}
static int _wrap_SBStructuredData_GetStringValue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ;
char *arg2 = (char *) 0 ;
size_t arg3 ;
size_t result;
SWIG_check_num_args("lldb::SBStructuredData::GetStringValue",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetStringValue",1,"lldb::SBStructuredData const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBStructuredData_GetStringValue",1,SWIGTYPE_p_lldb__SBStructuredData);
}
{
arg3 = luaL_checkinteger(L, 2);
if (arg3 <= 0) {
return luaL_error(L, "Positive integer expected");
}
arg2 = (char *)malloc(arg3);
}
result = ((lldb::SBStructuredData const *)arg1)->GetStringValue(arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
{
lua_pop(L, 1); // Blow away the previous result
if (result == 0) {
lua_pushliteral(L, "");
} else {
lua_pushlstring(L, (const char *)arg2, result);
}
free(arg2);
// SWIG_arg was already incremented
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStructuredData_GetAsJSON(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ;
lldb::SBStream *arg2 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBStructuredData::GetAsJSON",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetAsJSON",1,"lldb::SBStructuredData const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBStructuredData::GetAsJSON",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBStructuredData_GetAsJSON",1,SWIGTYPE_p_lldb__SBStructuredData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBStructuredData_GetAsJSON",2,SWIGTYPE_p_lldb__SBStream);
}
result = ((lldb::SBStructuredData const *)arg1)->GetAsJSON(*arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStructuredData_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ;
lldb::SBStream *arg2 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBStructuredData::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetDescription",1,"lldb::SBStructuredData const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBStructuredData::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBStructuredData_GetDescription",1,SWIGTYPE_p_lldb__SBStructuredData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBStructuredData_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = ((lldb::SBStructuredData const *)arg1)->GetDescription(*arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStructuredData_SetFromJSON__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ;
lldb::SBStream *arg2 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBStructuredData::SetFromJSON",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::SetFromJSON",1,"lldb::SBStructuredData *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBStructuredData::SetFromJSON",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBStructuredData_SetFromJSON",1,SWIGTYPE_p_lldb__SBStructuredData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBStructuredData_SetFromJSON",2,SWIGTYPE_p_lldb__SBStream);
}
result = (arg1)->SetFromJSON(*arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStructuredData_SetFromJSON__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBStructuredData::SetFromJSON",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::SetFromJSON",1,"lldb::SBStructuredData *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBStructuredData::SetFromJSON",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBStructuredData_SetFromJSON",1,SWIGTYPE_p_lldb__SBStructuredData);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->SetFromJSON((char const *)arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBStructuredData_SetFromJSON(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBStructuredData_SetFromJSON__SWIG_0(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBStructuredData_SetFromJSON__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBStructuredData_SetFromJSON'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBStructuredData::SetFromJSON(lldb::SBStream &)\n"
" lldb::SBStructuredData::SetFromJSON(char const *)\n");
lua_error(L);return 0;
}
static void swig_delete_SBStructuredData(void *obj) {
lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBStructuredData(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBStructuredData);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBStructuredData_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBStructuredData_methods[]= {
{ "IsValid", _wrap_SBStructuredData_IsValid},
{ "Clear", _wrap_SBStructuredData_Clear},
{ "GetType", _wrap_SBStructuredData_GetType},
{ "GetSize", _wrap_SBStructuredData_GetSize},
{ "GetKeys", _wrap_SBStructuredData_GetKeys},
{ "GetValueForKey", _wrap_SBStructuredData_GetValueForKey},
{ "GetItemAtIndex", _wrap_SBStructuredData_GetItemAtIndex},
{ "GetIntegerValue", _wrap_SBStructuredData_GetIntegerValue},
{ "GetFloatValue", _wrap_SBStructuredData_GetFloatValue},
{ "GetBooleanValue", _wrap_SBStructuredData_GetBooleanValue},
{ "GetStringValue", _wrap_SBStructuredData_GetStringValue},
{ "GetAsJSON", _wrap_SBStructuredData_GetAsJSON},
{ "GetDescription", _wrap_SBStructuredData_GetDescription},
{ "SetFromJSON", _wrap_SBStructuredData_SetFromJSON},
{0,0}
};
static swig_lua_method swig_SBStructuredData_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBStructuredData_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBStructuredData_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBStructuredData_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBStructuredData_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBStructuredData_Sf_SwigStatic = {
"SBStructuredData",
swig_SBStructuredData_Sf_SwigStatic_methods,
swig_SBStructuredData_Sf_SwigStatic_attributes,
swig_SBStructuredData_Sf_SwigStatic_constants,
swig_SBStructuredData_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBStructuredData_bases[] = {0};
static const char *swig_SBStructuredData_base_names[] = {0};
static swig_lua_class _wrap_class_SBStructuredData = { "SBStructuredData", "SBStructuredData", &SWIGTYPE_p_lldb__SBStructuredData,_proxy__wrap_new_SBStructuredData, swig_delete_SBStructuredData, swig_SBStructuredData_methods, swig_SBStructuredData_attributes, &swig_SBStructuredData_Sf_SwigStatic, swig_SBStructuredData_meta, swig_SBStructuredData_bases, swig_SBStructuredData_base_names };
static int _wrap_new_SBSymbol__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbol *result = 0 ;
SWIG_check_num_args("lldb::SBSymbol::SBSymbol",0,0)
result = (lldb::SBSymbol *)new lldb::SBSymbol();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSymbol,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBSymbol__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbol *arg1 = 0 ;
lldb::SBSymbol *result = 0 ;
SWIG_check_num_args("lldb::SBSymbol::SBSymbol",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBSymbol::SBSymbol",1,"lldb::SBSymbol const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){
SWIG_fail_ptr("new_SBSymbol",1,SWIGTYPE_p_lldb__SBSymbol);
}
result = (lldb::SBSymbol *)new lldb::SBSymbol((lldb::SBSymbol const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSymbol,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBSymbol(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBSymbol__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSymbol, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBSymbol__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBSymbol'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBSymbol::SBSymbol()\n"
" lldb::SBSymbol::SBSymbol(lldb::SBSymbol const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBSymbol_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBSymbol::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::IsValid",1,"lldb::SBSymbol const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){
SWIG_fail_ptr("SBSymbol_IsValid",1,SWIGTYPE_p_lldb__SBSymbol);
}
result = (bool)((lldb::SBSymbol const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbol_GetName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBSymbol::GetName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetName",1,"lldb::SBSymbol const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){
SWIG_fail_ptr("SBSymbol_GetName",1,SWIGTYPE_p_lldb__SBSymbol);
}
result = (char *)((lldb::SBSymbol const *)arg1)->GetName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbol_GetDisplayName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBSymbol::GetDisplayName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetDisplayName",1,"lldb::SBSymbol const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){
SWIG_fail_ptr("SBSymbol_GetDisplayName",1,SWIGTYPE_p_lldb__SBSymbol);
}
result = (char *)((lldb::SBSymbol const *)arg1)->GetDisplayName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbol_GetMangledName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBSymbol::GetMangledName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetMangledName",1,"lldb::SBSymbol const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){
SWIG_fail_ptr("SBSymbol_GetMangledName",1,SWIGTYPE_p_lldb__SBSymbol);
}
result = (char *)((lldb::SBSymbol const *)arg1)->GetMangledName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbol_GetInstructions__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ;
lldb::SBTarget arg2 ;
lldb::SBTarget *argp2 ;
lldb::SBInstructionList result;
SWIG_check_num_args("lldb::SBSymbol::GetInstructions",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetInstructions",1,"lldb::SBSymbol *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbol::GetInstructions",2,"lldb::SBTarget");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){
SWIG_fail_ptr("SBSymbol_GetInstructions",1,SWIGTYPE_p_lldb__SBSymbol);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBSymbol_GetInstructions",2,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = *argp2;
result = (arg1)->GetInstructions(arg2);
{
lldb::SBInstructionList * resultptr = new lldb::SBInstructionList((const lldb::SBInstructionList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbol_GetInstructions__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ;
lldb::SBTarget arg2 ;
char *arg3 = (char *) 0 ;
lldb::SBTarget *argp2 ;
lldb::SBInstructionList result;
SWIG_check_num_args("lldb::SBSymbol::GetInstructions",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetInstructions",1,"lldb::SBSymbol *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbol::GetInstructions",2,"lldb::SBTarget");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBSymbol::GetInstructions",3,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){
SWIG_fail_ptr("SBSymbol_GetInstructions",1,SWIGTYPE_p_lldb__SBSymbol);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBSymbol_GetInstructions",2,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = *argp2;
arg3 = (char *)lua_tostring(L, 3);
result = (arg1)->GetInstructions(arg2,(char const *)arg3);
{
lldb::SBInstructionList * resultptr = new lldb::SBInstructionList((const lldb::SBInstructionList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbol_GetInstructions(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSymbol, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBSymbol_GetInstructions__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSymbol, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[2]);
}
if (_v) {
return _wrap_SBSymbol_GetInstructions__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBSymbol_GetInstructions'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBSymbol::GetInstructions(lldb::SBTarget)\n"
" lldb::SBSymbol::GetInstructions(lldb::SBTarget,char const *)\n");
lua_error(L);return 0;
}
static int _wrap_SBSymbol_GetStartAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBSymbol::GetStartAddress",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetStartAddress",1,"lldb::SBSymbol *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){
SWIG_fail_ptr("SBSymbol_GetStartAddress",1,SWIGTYPE_p_lldb__SBSymbol);
}
result = (arg1)->GetStartAddress();
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbol_GetEndAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBSymbol::GetEndAddress",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetEndAddress",1,"lldb::SBSymbol *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){
SWIG_fail_ptr("SBSymbol_GetEndAddress",1,SWIGTYPE_p_lldb__SBSymbol);
}
result = (arg1)->GetEndAddress();
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbol_GetPrologueByteSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBSymbol::GetPrologueByteSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetPrologueByteSize",1,"lldb::SBSymbol *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){
SWIG_fail_ptr("SBSymbol_GetPrologueByteSize",1,SWIGTYPE_p_lldb__SBSymbol);
}
result = (uint32_t)(arg1)->GetPrologueByteSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbol_GetType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ;
lldb::SymbolType result;
SWIG_check_num_args("lldb::SBSymbol::GetType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetType",1,"lldb::SBSymbol *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){
SWIG_fail_ptr("SBSymbol_GetType",1,SWIGTYPE_p_lldb__SBSymbol);
}
result = (lldb::SymbolType)(arg1)->GetType();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbol_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBSymbol::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetDescription",1,"lldb::SBSymbol *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbol::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){
SWIG_fail_ptr("SBSymbol_GetDescription",1,SWIGTYPE_p_lldb__SBSymbol);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBSymbol_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbol_IsExternal(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBSymbol::IsExternal",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::IsExternal",1,"lldb::SBSymbol *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){
SWIG_fail_ptr("SBSymbol_IsExternal",1,SWIGTYPE_p_lldb__SBSymbol);
}
result = (bool)(arg1)->IsExternal();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbol_IsSynthetic(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBSymbol::IsSynthetic",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::IsSynthetic",1,"lldb::SBSymbol *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){
SWIG_fail_ptr("SBSymbol_IsSynthetic",1,SWIGTYPE_p_lldb__SBSymbol);
}
result = (bool)(arg1)->IsSynthetic();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbol___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ;
lldb::SBSymbol *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBSymbol::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::operator ==",1,"lldb::SBSymbol const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbol::operator ==",2,"lldb::SBSymbol const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){
SWIG_fail_ptr("SBSymbol___eq",1,SWIGTYPE_p_lldb__SBSymbol);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBSymbol,0))){
SWIG_fail_ptr("SBSymbol___eq",2,SWIGTYPE_p_lldb__SBSymbol);
}
result = (bool)((lldb::SBSymbol const *)arg1)->operator ==((lldb::SBSymbol const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbol___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBSymbol::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::__str__",1,"lldb::SBSymbol *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){
SWIG_fail_ptr("SBSymbol___tostring",1,SWIGTYPE_p_lldb__SBSymbol);
}
result = lldb_SBSymbol___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBSymbol(void *obj) {
lldb::SBSymbol *arg1 = (lldb::SBSymbol *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBSymbol(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBSymbol);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBSymbol_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBSymbol_methods[]= {
{ "IsValid", _wrap_SBSymbol_IsValid},
{ "GetName", _wrap_SBSymbol_GetName},
{ "GetDisplayName", _wrap_SBSymbol_GetDisplayName},
{ "GetMangledName", _wrap_SBSymbol_GetMangledName},
{ "GetInstructions", _wrap_SBSymbol_GetInstructions},
{ "GetStartAddress", _wrap_SBSymbol_GetStartAddress},
{ "GetEndAddress", _wrap_SBSymbol_GetEndAddress},
{ "GetPrologueByteSize", _wrap_SBSymbol_GetPrologueByteSize},
{ "GetType", _wrap_SBSymbol_GetType},
{ "GetDescription", _wrap_SBSymbol_GetDescription},
{ "IsExternal", _wrap_SBSymbol_IsExternal},
{ "IsSynthetic", _wrap_SBSymbol_IsSynthetic},
{ "__eq", _wrap_SBSymbol___eq},
{ "__tostring", _wrap_SBSymbol___tostring},
{0,0}
};
static swig_lua_method swig_SBSymbol_meta[] = {
{ "__eq", _wrap_SBSymbol___eq},
{ "__tostring", _wrap_SBSymbol___tostring},
{0,0}
};
static swig_lua_attribute swig_SBSymbol_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBSymbol_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBSymbol_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBSymbol_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBSymbol_Sf_SwigStatic = {
"SBSymbol",
swig_SBSymbol_Sf_SwigStatic_methods,
swig_SBSymbol_Sf_SwigStatic_attributes,
swig_SBSymbol_Sf_SwigStatic_constants,
swig_SBSymbol_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBSymbol_bases[] = {0};
static const char *swig_SBSymbol_base_names[] = {0};
static swig_lua_class _wrap_class_SBSymbol = { "SBSymbol", "SBSymbol", &SWIGTYPE_p_lldb__SBSymbol,_proxy__wrap_new_SBSymbol, swig_delete_SBSymbol, swig_SBSymbol_methods, swig_SBSymbol_attributes, &swig_SBSymbol_Sf_SwigStatic, swig_SBSymbol_meta, swig_SBSymbol_bases, swig_SBSymbol_base_names };
static int _wrap_new_SBSymbolContext__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContext *result = 0 ;
SWIG_check_num_args("lldb::SBSymbolContext::SBSymbolContext",0,0)
result = (lldb::SBSymbolContext *)new lldb::SBSymbolContext();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSymbolContext,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBSymbolContext__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContext *arg1 = 0 ;
lldb::SBSymbolContext *result = 0 ;
SWIG_check_num_args("lldb::SBSymbolContext::SBSymbolContext",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::SBSymbolContext",1,"lldb::SBSymbolContext const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){
SWIG_fail_ptr("new_SBSymbolContext",1,SWIGTYPE_p_lldb__SBSymbolContext);
}
result = (lldb::SBSymbolContext *)new lldb::SBSymbolContext((lldb::SBSymbolContext const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSymbolContext,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBSymbolContext(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBSymbolContext__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSymbolContext, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBSymbolContext__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBSymbolContext'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBSymbolContext::SBSymbolContext()\n"
" lldb::SBSymbolContext::SBSymbolContext(lldb::SBSymbolContext const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBSymbolContext_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBSymbolContext::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::IsValid",1,"lldb::SBSymbolContext const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){
SWIG_fail_ptr("SBSymbolContext_IsValid",1,SWIGTYPE_p_lldb__SBSymbolContext);
}
result = (bool)((lldb::SBSymbolContext const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContext_GetModule(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ;
lldb::SBModule result;
SWIG_check_num_args("lldb::SBSymbolContext::GetModule",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::GetModule",1,"lldb::SBSymbolContext *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){
SWIG_fail_ptr("SBSymbolContext_GetModule",1,SWIGTYPE_p_lldb__SBSymbolContext);
}
result = (arg1)->GetModule();
{
lldb::SBModule * resultptr = new lldb::SBModule((const lldb::SBModule &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContext_GetCompileUnit(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ;
lldb::SBCompileUnit result;
SWIG_check_num_args("lldb::SBSymbolContext::GetCompileUnit",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::GetCompileUnit",1,"lldb::SBSymbolContext *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){
SWIG_fail_ptr("SBSymbolContext_GetCompileUnit",1,SWIGTYPE_p_lldb__SBSymbolContext);
}
result = (arg1)->GetCompileUnit();
{
lldb::SBCompileUnit * resultptr = new lldb::SBCompileUnit((const lldb::SBCompileUnit &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBCompileUnit,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContext_GetFunction(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ;
lldb::SBFunction result;
SWIG_check_num_args("lldb::SBSymbolContext::GetFunction",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::GetFunction",1,"lldb::SBSymbolContext *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){
SWIG_fail_ptr("SBSymbolContext_GetFunction",1,SWIGTYPE_p_lldb__SBSymbolContext);
}
result = (arg1)->GetFunction();
{
lldb::SBFunction * resultptr = new lldb::SBFunction((const lldb::SBFunction &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFunction,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContext_GetBlock(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ;
lldb::SBBlock result;
SWIG_check_num_args("lldb::SBSymbolContext::GetBlock",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::GetBlock",1,"lldb::SBSymbolContext *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){
SWIG_fail_ptr("SBSymbolContext_GetBlock",1,SWIGTYPE_p_lldb__SBSymbolContext);
}
result = (arg1)->GetBlock();
{
lldb::SBBlock * resultptr = new lldb::SBBlock((const lldb::SBBlock &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContext_GetLineEntry(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ;
lldb::SBLineEntry result;
SWIG_check_num_args("lldb::SBSymbolContext::GetLineEntry",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::GetLineEntry",1,"lldb::SBSymbolContext *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){
SWIG_fail_ptr("SBSymbolContext_GetLineEntry",1,SWIGTYPE_p_lldb__SBSymbolContext);
}
result = (arg1)->GetLineEntry();
{
lldb::SBLineEntry * resultptr = new lldb::SBLineEntry((const lldb::SBLineEntry &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBLineEntry,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContext_GetSymbol(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ;
lldb::SBSymbol result;
SWIG_check_num_args("lldb::SBSymbolContext::GetSymbol",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::GetSymbol",1,"lldb::SBSymbolContext *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){
SWIG_fail_ptr("SBSymbolContext_GetSymbol",1,SWIGTYPE_p_lldb__SBSymbolContext);
}
result = (arg1)->GetSymbol();
{
lldb::SBSymbol * resultptr = new lldb::SBSymbol((const lldb::SBSymbol &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbol,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContext_SetModule(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ;
lldb::SBModule arg2 ;
lldb::SBModule *argp2 ;
SWIG_check_num_args("lldb::SBSymbolContext::SetModule",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::SetModule",1,"lldb::SBSymbolContext *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContext::SetModule",2,"lldb::SBModule");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){
SWIG_fail_ptr("SBSymbolContext_SetModule",1,SWIGTYPE_p_lldb__SBSymbolContext);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBSymbolContext_SetModule",2,SWIGTYPE_p_lldb__SBModule);
}
arg2 = *argp2;
(arg1)->SetModule(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContext_SetCompileUnit(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ;
lldb::SBCompileUnit arg2 ;
lldb::SBCompileUnit *argp2 ;
SWIG_check_num_args("lldb::SBSymbolContext::SetCompileUnit",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::SetCompileUnit",1,"lldb::SBSymbolContext *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContext::SetCompileUnit",2,"lldb::SBCompileUnit");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){
SWIG_fail_ptr("SBSymbolContext_SetCompileUnit",1,SWIGTYPE_p_lldb__SBSymbolContext);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBCompileUnit,0))){
SWIG_fail_ptr("SBSymbolContext_SetCompileUnit",2,SWIGTYPE_p_lldb__SBCompileUnit);
}
arg2 = *argp2;
(arg1)->SetCompileUnit(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContext_SetFunction(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ;
lldb::SBFunction arg2 ;
lldb::SBFunction *argp2 ;
SWIG_check_num_args("lldb::SBSymbolContext::SetFunction",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::SetFunction",1,"lldb::SBSymbolContext *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContext::SetFunction",2,"lldb::SBFunction");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){
SWIG_fail_ptr("SBSymbolContext_SetFunction",1,SWIGTYPE_p_lldb__SBSymbolContext);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFunction,0))){
SWIG_fail_ptr("SBSymbolContext_SetFunction",2,SWIGTYPE_p_lldb__SBFunction);
}
arg2 = *argp2;
(arg1)->SetFunction(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContext_SetBlock(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ;
lldb::SBBlock arg2 ;
lldb::SBBlock *argp2 ;
SWIG_check_num_args("lldb::SBSymbolContext::SetBlock",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::SetBlock",1,"lldb::SBSymbolContext *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContext::SetBlock",2,"lldb::SBBlock");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){
SWIG_fail_ptr("SBSymbolContext_SetBlock",1,SWIGTYPE_p_lldb__SBSymbolContext);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBBlock,0))){
SWIG_fail_ptr("SBSymbolContext_SetBlock",2,SWIGTYPE_p_lldb__SBBlock);
}
arg2 = *argp2;
(arg1)->SetBlock(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContext_SetLineEntry(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ;
lldb::SBLineEntry arg2 ;
lldb::SBLineEntry *argp2 ;
SWIG_check_num_args("lldb::SBSymbolContext::SetLineEntry",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::SetLineEntry",1,"lldb::SBSymbolContext *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContext::SetLineEntry",2,"lldb::SBLineEntry");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){
SWIG_fail_ptr("SBSymbolContext_SetLineEntry",1,SWIGTYPE_p_lldb__SBSymbolContext);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBLineEntry,0))){
SWIG_fail_ptr("SBSymbolContext_SetLineEntry",2,SWIGTYPE_p_lldb__SBLineEntry);
}
arg2 = *argp2;
(arg1)->SetLineEntry(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContext_SetSymbol(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ;
lldb::SBSymbol arg2 ;
lldb::SBSymbol *argp2 ;
SWIG_check_num_args("lldb::SBSymbolContext::SetSymbol",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::SetSymbol",1,"lldb::SBSymbolContext *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContext::SetSymbol",2,"lldb::SBSymbol");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){
SWIG_fail_ptr("SBSymbolContext_SetSymbol",1,SWIGTYPE_p_lldb__SBSymbolContext);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBSymbol,0))){
SWIG_fail_ptr("SBSymbolContext_SetSymbol",2,SWIGTYPE_p_lldb__SBSymbol);
}
arg2 = *argp2;
(arg1)->SetSymbol(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContext_GetParentOfInlinedScope(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ;
lldb::SBAddress *arg2 = 0 ;
lldb::SBAddress *arg3 = 0 ;
lldb::SBSymbolContext result;
SWIG_check_num_args("lldb::SBSymbolContext::GetParentOfInlinedScope",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::GetParentOfInlinedScope",1,"lldb::SBSymbolContext const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContext::GetParentOfInlinedScope",2,"lldb::SBAddress const &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBSymbolContext::GetParentOfInlinedScope",3,"lldb::SBAddress &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){
SWIG_fail_ptr("SBSymbolContext_GetParentOfInlinedScope",1,SWIGTYPE_p_lldb__SBSymbolContext);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBSymbolContext_GetParentOfInlinedScope",2,SWIGTYPE_p_lldb__SBAddress);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBSymbolContext_GetParentOfInlinedScope",3,SWIGTYPE_p_lldb__SBAddress);
}
result = ((lldb::SBSymbolContext const *)arg1)->GetParentOfInlinedScope((lldb::SBAddress const &)*arg2,*arg3);
{
lldb::SBSymbolContext * resultptr = new lldb::SBSymbolContext((const lldb::SBSymbolContext &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContext,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContext_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBSymbolContext::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::GetDescription",1,"lldb::SBSymbolContext *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContext::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){
SWIG_fail_ptr("SBSymbolContext_GetDescription",1,SWIGTYPE_p_lldb__SBSymbolContext);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBSymbolContext_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContext___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBSymbolContext::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::__str__",1,"lldb::SBSymbolContext *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){
SWIG_fail_ptr("SBSymbolContext___tostring",1,SWIGTYPE_p_lldb__SBSymbolContext);
}
result = lldb_SBSymbolContext___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBSymbolContext(void *obj) {
lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBSymbolContext(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBSymbolContext);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBSymbolContext_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBSymbolContext_methods[]= {
{ "IsValid", _wrap_SBSymbolContext_IsValid},
{ "GetModule", _wrap_SBSymbolContext_GetModule},
{ "GetCompileUnit", _wrap_SBSymbolContext_GetCompileUnit},
{ "GetFunction", _wrap_SBSymbolContext_GetFunction},
{ "GetBlock", _wrap_SBSymbolContext_GetBlock},
{ "GetLineEntry", _wrap_SBSymbolContext_GetLineEntry},
{ "GetSymbol", _wrap_SBSymbolContext_GetSymbol},
{ "SetModule", _wrap_SBSymbolContext_SetModule},
{ "SetCompileUnit", _wrap_SBSymbolContext_SetCompileUnit},
{ "SetFunction", _wrap_SBSymbolContext_SetFunction},
{ "SetBlock", _wrap_SBSymbolContext_SetBlock},
{ "SetLineEntry", _wrap_SBSymbolContext_SetLineEntry},
{ "SetSymbol", _wrap_SBSymbolContext_SetSymbol},
{ "GetParentOfInlinedScope", _wrap_SBSymbolContext_GetParentOfInlinedScope},
{ "GetDescription", _wrap_SBSymbolContext_GetDescription},
{ "__tostring", _wrap_SBSymbolContext___tostring},
{0,0}
};
static swig_lua_method swig_SBSymbolContext_meta[] = {
{ "__tostring", _wrap_SBSymbolContext___tostring},
{0,0}
};
static swig_lua_attribute swig_SBSymbolContext_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBSymbolContext_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBSymbolContext_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBSymbolContext_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBSymbolContext_Sf_SwigStatic = {
"SBSymbolContext",
swig_SBSymbolContext_Sf_SwigStatic_methods,
swig_SBSymbolContext_Sf_SwigStatic_attributes,
swig_SBSymbolContext_Sf_SwigStatic_constants,
swig_SBSymbolContext_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBSymbolContext_bases[] = {0};
static const char *swig_SBSymbolContext_base_names[] = {0};
static swig_lua_class _wrap_class_SBSymbolContext = { "SBSymbolContext", "SBSymbolContext", &SWIGTYPE_p_lldb__SBSymbolContext,_proxy__wrap_new_SBSymbolContext, swig_delete_SBSymbolContext, swig_SBSymbolContext_methods, swig_SBSymbolContext_attributes, &swig_SBSymbolContext_Sf_SwigStatic, swig_SBSymbolContext_meta, swig_SBSymbolContext_bases, swig_SBSymbolContext_base_names };
static int _wrap_new_SBSymbolContextList__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContextList *result = 0 ;
SWIG_check_num_args("lldb::SBSymbolContextList::SBSymbolContextList",0,0)
result = (lldb::SBSymbolContextList *)new lldb::SBSymbolContextList();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBSymbolContextList__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContextList *arg1 = 0 ;
lldb::SBSymbolContextList *result = 0 ;
SWIG_check_num_args("lldb::SBSymbolContextList::SBSymbolContextList",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBSymbolContextList::SBSymbolContextList",1,"lldb::SBSymbolContextList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContextList,0))){
SWIG_fail_ptr("new_SBSymbolContextList",1,SWIGTYPE_p_lldb__SBSymbolContextList);
}
result = (lldb::SBSymbolContextList *)new lldb::SBSymbolContextList((lldb::SBSymbolContextList const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBSymbolContextList(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBSymbolContextList__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBSymbolContextList__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBSymbolContextList'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBSymbolContextList::SBSymbolContextList()\n"
" lldb::SBSymbolContextList::SBSymbolContextList(lldb::SBSymbolContextList const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBSymbolContextList_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBSymbolContextList::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContextList::IsValid",1,"lldb::SBSymbolContextList const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContextList,0))){
SWIG_fail_ptr("SBSymbolContextList_IsValid",1,SWIGTYPE_p_lldb__SBSymbolContextList);
}
result = (bool)((lldb::SBSymbolContextList const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContextList_GetSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBSymbolContextList::GetSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContextList::GetSize",1,"lldb::SBSymbolContextList const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContextList,0))){
SWIG_fail_ptr("SBSymbolContextList_GetSize",1,SWIGTYPE_p_lldb__SBSymbolContextList);
}
result = (uint32_t)((lldb::SBSymbolContextList const *)arg1)->GetSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContextList_GetContextAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ;
uint32_t arg2 ;
lldb::SBSymbolContext result;
SWIG_check_num_args("lldb::SBSymbolContextList::GetContextAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContextList::GetContextAtIndex",1,"lldb::SBSymbolContextList *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBSymbolContextList::GetContextAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContextList,0))){
SWIG_fail_ptr("SBSymbolContextList_GetContextAtIndex",1,SWIGTYPE_p_lldb__SBSymbolContextList);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetContextAtIndex(arg2);
{
lldb::SBSymbolContext * resultptr = new lldb::SBSymbolContext((const lldb::SBSymbolContext &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContext,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContextList_Append__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ;
lldb::SBSymbolContext *arg2 = 0 ;
SWIG_check_num_args("lldb::SBSymbolContextList::Append",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContextList::Append",1,"lldb::SBSymbolContextList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContextList::Append",2,"lldb::SBSymbolContext &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContextList,0))){
SWIG_fail_ptr("SBSymbolContextList_Append",1,SWIGTYPE_p_lldb__SBSymbolContextList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBSymbolContext,0))){
SWIG_fail_ptr("SBSymbolContextList_Append",2,SWIGTYPE_p_lldb__SBSymbolContext);
}
(arg1)->Append(*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContextList_Append__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ;
lldb::SBSymbolContextList *arg2 = 0 ;
SWIG_check_num_args("lldb::SBSymbolContextList::Append",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContextList::Append",1,"lldb::SBSymbolContextList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContextList::Append",2,"lldb::SBSymbolContextList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContextList,0))){
SWIG_fail_ptr("SBSymbolContextList_Append",1,SWIGTYPE_p_lldb__SBSymbolContextList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBSymbolContextList,0))){
SWIG_fail_ptr("SBSymbolContextList_Append",2,SWIGTYPE_p_lldb__SBSymbolContextList);
}
(arg1)->Append(*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContextList_Append(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSymbolContextList, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBSymbolContext, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBSymbolContextList_Append__SWIG_0(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSymbolContextList, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBSymbolContextList_Append__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBSymbolContextList_Append'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBSymbolContextList::Append(lldb::SBSymbolContext &)\n"
" lldb::SBSymbolContextList::Append(lldb::SBSymbolContextList &)\n");
lua_error(L);return 0;
}
static int _wrap_SBSymbolContextList_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBSymbolContextList::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContextList::GetDescription",1,"lldb::SBSymbolContextList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContextList::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContextList,0))){
SWIG_fail_ptr("SBSymbolContextList_GetDescription",1,SWIGTYPE_p_lldb__SBSymbolContextList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBSymbolContextList_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContextList_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ;
SWIG_check_num_args("lldb::SBSymbolContextList::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContextList::Clear",1,"lldb::SBSymbolContextList *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContextList,0))){
SWIG_fail_ptr("SBSymbolContextList_Clear",1,SWIGTYPE_p_lldb__SBSymbolContextList);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBSymbolContextList___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBSymbolContextList::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContextList::__str__",1,"lldb::SBSymbolContextList *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContextList,0))){
SWIG_fail_ptr("SBSymbolContextList___tostring",1,SWIGTYPE_p_lldb__SBSymbolContextList);
}
result = lldb_SBSymbolContextList___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBSymbolContextList(void *obj) {
lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBSymbolContextList(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBSymbolContextList);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBSymbolContextList_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBSymbolContextList_methods[]= {
{ "IsValid", _wrap_SBSymbolContextList_IsValid},
{ "GetSize", _wrap_SBSymbolContextList_GetSize},
{ "GetContextAtIndex", _wrap_SBSymbolContextList_GetContextAtIndex},
{ "Append", _wrap_SBSymbolContextList_Append},
{ "GetDescription", _wrap_SBSymbolContextList_GetDescription},
{ "Clear", _wrap_SBSymbolContextList_Clear},
{ "__tostring", _wrap_SBSymbolContextList___tostring},
{0,0}
};
static swig_lua_method swig_SBSymbolContextList_meta[] = {
{ "__tostring", _wrap_SBSymbolContextList___tostring},
{0,0}
};
static swig_lua_attribute swig_SBSymbolContextList_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBSymbolContextList_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBSymbolContextList_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBSymbolContextList_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBSymbolContextList_Sf_SwigStatic = {
"SBSymbolContextList",
swig_SBSymbolContextList_Sf_SwigStatic_methods,
swig_SBSymbolContextList_Sf_SwigStatic_attributes,
swig_SBSymbolContextList_Sf_SwigStatic_constants,
swig_SBSymbolContextList_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBSymbolContextList_bases[] = {0};
static const char *swig_SBSymbolContextList_base_names[] = {0};
static swig_lua_class _wrap_class_SBSymbolContextList = { "SBSymbolContextList", "SBSymbolContextList", &SWIGTYPE_p_lldb__SBSymbolContextList,_proxy__wrap_new_SBSymbolContextList, swig_delete_SBSymbolContextList, swig_SBSymbolContextList_methods, swig_SBSymbolContextList_attributes, &swig_SBSymbolContextList_Sf_SwigStatic, swig_SBSymbolContextList_meta, swig_SBSymbolContextList_bases, swig_SBSymbolContextList_base_names };
static int _wrap_new_SBTarget__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *result = 0 ;
SWIG_check_num_args("lldb::SBTarget::SBTarget",0,0)
result = (lldb::SBTarget *)new lldb::SBTarget();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTarget__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = 0 ;
lldb::SBTarget *result = 0 ;
SWIG_check_num_args("lldb::SBTarget::SBTarget",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTarget::SBTarget",1,"lldb::SBTarget const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("new_SBTarget",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (lldb::SBTarget *)new lldb::SBTarget((lldb::SBTarget const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTarget(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBTarget__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBTarget__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTarget'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTarget::SBTarget()\n"
" lldb::SBTarget::SBTarget(lldb::SBTarget const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTarget_GetBroadcasterClassName(lua_State* L) {
int SWIG_arg = 0;
char *result = 0 ;
SWIG_check_num_args("lldb::SBTarget::GetBroadcasterClassName",0,0)
result = (char *)lldb::SBTarget::GetBroadcasterClassName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTarget::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::IsValid",1,"lldb::SBTarget const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_IsValid",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (bool)((lldb::SBTarget const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_EventIsTargetEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBTarget::EventIsTargetEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTarget::EventIsTargetEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBTarget_EventIsTargetEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)lldb::SBTarget::EventIsTargetEvent((lldb::SBEvent const &)*arg1);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetTargetFromEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
lldb::SBTarget result;
SWIG_check_num_args("lldb::SBTarget::GetTargetFromEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTarget::GetTargetFromEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBTarget_GetTargetFromEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = lldb::SBTarget::GetTargetFromEvent((lldb::SBEvent const &)*arg1);
{
lldb::SBTarget * resultptr = new lldb::SBTarget((const lldb::SBTarget &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetNumModulesFromEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTarget::GetNumModulesFromEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTarget::GetNumModulesFromEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBTarget_GetNumModulesFromEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (uint32_t)lldb::SBTarget::GetNumModulesFromEvent((lldb::SBEvent const &)*arg1);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetModuleAtIndexFromEvent(lua_State* L) {
int SWIG_arg = 0;
uint32_t arg1 ;
lldb::SBEvent *arg2 = 0 ;
lldb::SBModule result;
SWIG_check_num_args("lldb::SBTarget::GetModuleAtIndexFromEvent",2,2)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBTarget::GetModuleAtIndexFromEvent",1,"uint32_t const");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::GetModuleAtIndexFromEvent",2,"lldb::SBEvent const &");
arg1 = (uint32_t const)lua_tointeger(L, 1);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBTarget_GetModuleAtIndexFromEvent",2,SWIGTYPE_p_lldb__SBEvent);
}
result = lldb::SBTarget::GetModuleAtIndexFromEvent(arg1,(lldb::SBEvent const &)*arg2);
{
lldb::SBModule * resultptr = new lldb::SBModule((const lldb::SBModule &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetProcess(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBProcess result;
SWIG_check_num_args("lldb::SBTarget::GetProcess",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetProcess",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetProcess",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (arg1)->GetProcess();
{
lldb::SBProcess * resultptr = new lldb::SBProcess((const lldb::SBProcess &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetPlatform(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBPlatform result;
SWIG_check_num_args("lldb::SBTarget::GetPlatform",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetPlatform",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetPlatform",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (arg1)->GetPlatform();
{
lldb::SBPlatform * resultptr = new lldb::SBPlatform((const lldb::SBPlatform &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBPlatform,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_Install(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBTarget::Install",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::Install",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_Install",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (arg1)->Install();
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_Launch__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBListener *arg2 = 0 ;
char **arg3 = (char **) 0 ;
char **arg4 = (char **) 0 ;
char *arg5 = (char *) 0 ;
char *arg6 = (char *) 0 ;
char *arg7 = (char *) 0 ;
char *arg8 = (char *) 0 ;
uint32_t arg9 ;
bool arg10 ;
lldb::SBError *arg11 = 0 ;
lldb::SBProcess result;
SWIG_check_num_args("lldb::SBTarget::Launch",11,11)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::Launch",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::Launch",2,"lldb::SBListener &");
if(!SWIG_lua_isnilstring(L,5)) SWIG_fail_arg("lldb::SBTarget::Launch",5,"char const *");
if(!SWIG_lua_isnilstring(L,6)) SWIG_fail_arg("lldb::SBTarget::Launch",6,"char const *");
if(!SWIG_lua_isnilstring(L,7)) SWIG_fail_arg("lldb::SBTarget::Launch",7,"char const *");
if(!SWIG_lua_isnilstring(L,8)) SWIG_fail_arg("lldb::SBTarget::Launch",8,"char const *");
if(!lua_isinteger(L,9)) SWIG_fail_arg("lldb::SBTarget::Launch",9,"uint32_t");
if(!lua_isboolean(L,10)) SWIG_fail_arg("lldb::SBTarget::Launch",10,"bool");
if(!lua_isuserdata(L,11)) SWIG_fail_arg("lldb::SBTarget::Launch",11,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_Launch",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBTarget_Launch",2,SWIGTYPE_p_lldb__SBListener);
}
{
if (lua_istable(L, 3)) {
size_t size = lua_rawlen(L, 3);
arg3 = (char **)malloc((size + 1) * sizeof(char *));
int i = 0, j = 0;
while (i++ < size) {
lua_rawgeti(L, 3, i);
if (!lua_isstring(L, -1)) {
// if current element cannot be converted to string, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain strings");
}
arg3[j++] = (char *)lua_tostring(L, -1);
lua_pop(L, 1);
}
arg3[j] = 0;
} else if (lua_isnil(L, 3)) {
// "nil" is also acceptable, equivalent as an empty table
arg3 = NULL;
} else {
return luaL_error(L, "A list of strings expected");
}
}
{
if (lua_istable(L, 4)) {
size_t size = lua_rawlen(L, 4);
arg4 = (char **)malloc((size + 1) * sizeof(char *));
int i = 0, j = 0;
while (i++ < size) {
lua_rawgeti(L, 4, i);
if (!lua_isstring(L, -1)) {
// if current element cannot be converted to string, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain strings");
}
arg4[j++] = (char *)lua_tostring(L, -1);
lua_pop(L, 1);
}
arg4[j] = 0;
} else if (lua_isnil(L, 4)) {
// "nil" is also acceptable, equivalent as an empty table
arg4 = NULL;
} else {
return luaL_error(L, "A list of strings expected");
}
}
arg5 = (char *)lua_tostring(L, 5);
arg6 = (char *)lua_tostring(L, 6);
arg7 = (char *)lua_tostring(L, 7);
arg8 = (char *)lua_tostring(L, 8);
arg9 = (uint32_t)lua_tointeger(L, 9);
arg10 = (lua_toboolean(L, 10)!=0);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,11,(void**)&arg11,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBTarget_Launch",11,SWIGTYPE_p_lldb__SBError);
}
result = (arg1)->Launch(*arg2,(char const **)arg3,(char const **)arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,(char const *)arg8,arg9,arg10,*arg11);
{
lldb::SBProcess * resultptr = new lldb::SBProcess((const lldb::SBProcess &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++;
}
{
free((char *) arg3);
}
{
free((char *) arg4);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free((char *) arg3);
}
{
free((char *) arg4);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_LaunchSimple(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char **arg2 = (char **) 0 ;
char **arg3 = (char **) 0 ;
char *arg4 = (char *) 0 ;
lldb::SBProcess result;
SWIG_check_num_args("lldb::SBTarget::LaunchSimple",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::LaunchSimple",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBTarget::LaunchSimple",4,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_LaunchSimple",1,SWIGTYPE_p_lldb__SBTarget);
}
{
if (lua_istable(L, 2)) {
size_t size = lua_rawlen(L, 2);
arg2 = (char **)malloc((size + 1) * sizeof(char *));
int i = 0, j = 0;
while (i++ < size) {
lua_rawgeti(L, 2, i);
if (!lua_isstring(L, -1)) {
// if current element cannot be converted to string, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain strings");
}
arg2[j++] = (char *)lua_tostring(L, -1);
lua_pop(L, 1);
}
arg2[j] = 0;
} else if (lua_isnil(L, 2)) {
// "nil" is also acceptable, equivalent as an empty table
arg2 = NULL;
} else {
return luaL_error(L, "A list of strings expected");
}
}
{
if (lua_istable(L, 3)) {
size_t size = lua_rawlen(L, 3);
arg3 = (char **)malloc((size + 1) * sizeof(char *));
int i = 0, j = 0;
while (i++ < size) {
lua_rawgeti(L, 3, i);
if (!lua_isstring(L, -1)) {
// if current element cannot be converted to string, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain strings");
}
arg3[j++] = (char *)lua_tostring(L, -1);
lua_pop(L, 1);
}
arg3[j] = 0;
} else if (lua_isnil(L, 3)) {
// "nil" is also acceptable, equivalent as an empty table
arg3 = NULL;
} else {
return luaL_error(L, "A list of strings expected");
}
}
arg4 = (char *)lua_tostring(L, 4);
result = (arg1)->LaunchSimple((char const **)arg2,(char const **)arg3,(char const *)arg4);
{
lldb::SBProcess * resultptr = new lldb::SBProcess((const lldb::SBProcess &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++;
}
{
free((char *) arg2);
}
{
free((char *) arg3);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free((char *) arg2);
}
{
free((char *) arg3);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_Launch__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBLaunchInfo *arg2 = 0 ;
lldb::SBError *arg3 = 0 ;
lldb::SBProcess result;
SWIG_check_num_args("lldb::SBTarget::Launch",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::Launch",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::Launch",2,"lldb::SBLaunchInfo &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::Launch",3,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_Launch",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBTarget_Launch",2,SWIGTYPE_p_lldb__SBLaunchInfo);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBTarget_Launch",3,SWIGTYPE_p_lldb__SBError);
}
result = (arg1)->Launch(*arg2,*arg3);
{
lldb::SBProcess * resultptr = new lldb::SBProcess((const lldb::SBProcess &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_Launch(lua_State* L) {
int argc;
int argv[12]={
1,2,3,4,5,6,7,8,9,10,11,12
};
argc = lua_gettop(L);
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBLaunchInfo, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_Launch__SWIG_1(L);
}
}
}
}
if (argc == 11) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_istable(L, argv[2]) || lua_isnil(L, argv[2]));
}
if (_v) {
{
_v = (lua_istable(L, argv[3]) || lua_isnil(L, argv[3]));
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[4]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[5]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[6]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[7]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[8]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[9]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[10])==0 || SWIG_ConvertPtr(L,argv[10], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_Launch__SWIG_0(L);
}
}
}
}
}
}
}
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTarget_Launch'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTarget::Launch(lldb::SBListener &,char const **,char const **,char const *,char const *,char const *,char const *,uint32_t,bool,lldb::SBError &)\n"
" lldb::SBTarget::Launch(lldb::SBLaunchInfo &,lldb::SBError &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTarget_LoadCore__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBProcess result;
SWIG_check_num_args("lldb::SBTarget::LoadCore",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::LoadCore",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::LoadCore",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_LoadCore",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->LoadCore((char const *)arg2);
{
lldb::SBProcess * resultptr = new lldb::SBProcess((const lldb::SBProcess &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_LoadCore__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBError *arg3 = 0 ;
lldb::SBProcess result;
SWIG_check_num_args("lldb::SBTarget::LoadCore",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::LoadCore",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::LoadCore",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::LoadCore",3,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_LoadCore",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBTarget_LoadCore",3,SWIGTYPE_p_lldb__SBError);
}
result = (arg1)->LoadCore((char const *)arg2,*arg3);
{
lldb::SBProcess * resultptr = new lldb::SBProcess((const lldb::SBProcess &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_LoadCore(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBTarget_LoadCore__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_LoadCore__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTarget_LoadCore'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTarget::LoadCore(char const *)\n"
" lldb::SBTarget::LoadCore(char const *,lldb::SBError &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTarget_Attach(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBAttachInfo *arg2 = 0 ;
lldb::SBError *arg3 = 0 ;
lldb::SBProcess result;
SWIG_check_num_args("lldb::SBTarget::Attach",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::Attach",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::Attach",2,"lldb::SBAttachInfo &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::Attach",3,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_Attach",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAttachInfo,0))){
SWIG_fail_ptr("SBTarget_Attach",2,SWIGTYPE_p_lldb__SBAttachInfo);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBTarget_Attach",3,SWIGTYPE_p_lldb__SBError);
}
result = (arg1)->Attach(*arg2,*arg3);
{
lldb::SBProcess * resultptr = new lldb::SBProcess((const lldb::SBProcess &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_AttachToProcessWithID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBListener *arg2 = 0 ;
lldb::pid_t arg3 ;
lldb::SBError *arg4 = 0 ;
lldb::SBProcess result;
SWIG_check_num_args("lldb::SBTarget::AttachToProcessWithID",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::AttachToProcessWithID",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::AttachToProcessWithID",2,"lldb::SBListener &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::AttachToProcessWithID",3,"lldb::pid_t");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::AttachToProcessWithID",4,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_AttachToProcessWithID",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBTarget_AttachToProcessWithID",2,SWIGTYPE_p_lldb__SBListener);
}
arg3 = (lldb::pid_t)lua_tointeger(L, 3);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBTarget_AttachToProcessWithID",4,SWIGTYPE_p_lldb__SBError);
}
result = (arg1)->AttachToProcessWithID(*arg2,arg3,*arg4);
{
lldb::SBProcess * resultptr = new lldb::SBProcess((const lldb::SBProcess &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_AttachToProcessWithName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBListener *arg2 = 0 ;
char *arg3 = (char *) 0 ;
bool arg4 ;
lldb::SBError *arg5 = 0 ;
lldb::SBProcess result;
SWIG_check_num_args("lldb::SBTarget::AttachToProcessWithName",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::AttachToProcessWithName",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::AttachToProcessWithName",2,"lldb::SBListener &");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTarget::AttachToProcessWithName",3,"char const *");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBTarget::AttachToProcessWithName",4,"bool");
if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::AttachToProcessWithName",5,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_AttachToProcessWithName",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBTarget_AttachToProcessWithName",2,SWIGTYPE_p_lldb__SBListener);
}
arg3 = (char *)lua_tostring(L, 3);
arg4 = (lua_toboolean(L, 4)!=0);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBTarget_AttachToProcessWithName",5,SWIGTYPE_p_lldb__SBError);
}
result = (arg1)->AttachToProcessWithName(*arg2,(char const *)arg3,arg4,*arg5);
{
lldb::SBProcess * resultptr = new lldb::SBProcess((const lldb::SBProcess &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_ConnectRemote(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBListener *arg2 = 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
lldb::SBError *arg5 = 0 ;
lldb::SBProcess result;
SWIG_check_num_args("lldb::SBTarget::ConnectRemote",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ConnectRemote",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::ConnectRemote",2,"lldb::SBListener &");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTarget::ConnectRemote",3,"char const *");
if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBTarget::ConnectRemote",4,"char const *");
if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::ConnectRemote",5,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_ConnectRemote",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){
SWIG_fail_ptr("SBTarget_ConnectRemote",2,SWIGTYPE_p_lldb__SBListener);
}
arg3 = (char *)lua_tostring(L, 3);
arg4 = (char *)lua_tostring(L, 4);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBTarget_ConnectRemote",5,SWIGTYPE_p_lldb__SBError);
}
result = (arg1)->ConnectRemote(*arg2,(char const *)arg3,(char const *)arg4,*arg5);
{
lldb::SBProcess * resultptr = new lldb::SBProcess((const lldb::SBProcess &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetExecutable(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBFileSpec result;
SWIG_check_num_args("lldb::SBTarget::GetExecutable",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetExecutable",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetExecutable",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (arg1)->GetExecutable();
{
lldb::SBFileSpec * resultptr = new lldb::SBFileSpec((const lldb::SBFileSpec &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_AppendImageSearchPath(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
lldb::SBError *arg4 = 0 ;
SWIG_check_num_args("lldb::SBTarget::AppendImageSearchPath",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::AppendImageSearchPath",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::AppendImageSearchPath",2,"char const *");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTarget::AppendImageSearchPath",3,"char const *");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::AppendImageSearchPath",4,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_AppendImageSearchPath",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (char *)lua_tostring(L, 3);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBTarget_AppendImageSearchPath",4,SWIGTYPE_p_lldb__SBError);
}
(arg1)->AppendImageSearchPath((char const *)arg2,(char const *)arg3,*arg4);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_AddModule__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBModule *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBTarget::AddModule",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::AddModule",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::AddModule",2,"lldb::SBModule &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_AddModule",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBTarget_AddModule",2,SWIGTYPE_p_lldb__SBModule);
}
result = (bool)(arg1)->AddModule(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_AddModule__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
lldb::SBModule result;
SWIG_check_num_args("lldb::SBTarget::AddModule",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::AddModule",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::AddModule",2,"char const *");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTarget::AddModule",3,"char const *");
if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBTarget::AddModule",4,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_AddModule",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (char *)lua_tostring(L, 3);
arg4 = (char *)lua_tostring(L, 4);
result = (arg1)->AddModule((char const *)arg2,(char const *)arg3,(char const *)arg4);
{
lldb::SBModule * resultptr = new lldb::SBModule((const lldb::SBModule &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_AddModule__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
char *arg5 = (char *) 0 ;
lldb::SBModule result;
SWIG_check_num_args("lldb::SBTarget::AddModule",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::AddModule",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::AddModule",2,"char const *");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTarget::AddModule",3,"char const *");
if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBTarget::AddModule",4,"char const *");
if(!SWIG_lua_isnilstring(L,5)) SWIG_fail_arg("lldb::SBTarget::AddModule",5,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_AddModule",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (char *)lua_tostring(L, 3);
arg4 = (char *)lua_tostring(L, 4);
arg5 = (char *)lua_tostring(L, 5);
result = (arg1)->AddModule((char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
{
lldb::SBModule * resultptr = new lldb::SBModule((const lldb::SBModule &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_AddModule__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBModuleSpec *arg2 = 0 ;
lldb::SBModule result;
SWIG_check_num_args("lldb::SBTarget::AddModule",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::AddModule",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::AddModule",2,"lldb::SBModuleSpec const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_AddModule",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBModuleSpec,0))){
SWIG_fail_ptr("SBTarget_AddModule",2,SWIGTYPE_p_lldb__SBModuleSpec);
}
result = (arg1)->AddModule((lldb::SBModuleSpec const &)*arg2);
{
lldb::SBModule * resultptr = new lldb::SBModule((const lldb::SBModule &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_AddModule(lua_State* L) {
int argc;
int argv[6]={
1,2,3,4,5,6
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_AddModule__SWIG_0(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBModuleSpec, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_AddModule__SWIG_3(L);
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[2]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[3]);
}
if (_v) {
return _wrap_SBTarget_AddModule__SWIG_1(L);
}
}
}
}
}
if (argc == 5) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[2]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[3]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[4]);
}
if (_v) {
return _wrap_SBTarget_AddModule__SWIG_2(L);
}
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTarget_AddModule'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTarget::AddModule(lldb::SBModule &)\n"
" lldb::SBTarget::AddModule(char const *,char const *,char const *)\n"
" lldb::SBTarget::AddModule(char const *,char const *,char const *,char const *)\n"
" lldb::SBTarget::AddModule(lldb::SBModuleSpec const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTarget_GetNumModules(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTarget::GetNumModules",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetNumModules",1,"lldb::SBTarget const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetNumModules",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (uint32_t)((lldb::SBTarget const *)arg1)->GetNumModules();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetModuleAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
uint32_t arg2 ;
lldb::SBModule result;
SWIG_check_num_args("lldb::SBTarget::GetModuleAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetModuleAtIndex",1,"lldb::SBTarget *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::GetModuleAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetModuleAtIndex",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetModuleAtIndex(arg2);
{
lldb::SBModule * resultptr = new lldb::SBModule((const lldb::SBModule &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_RemoveModule(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBModule arg2 ;
lldb::SBModule *argp2 ;
bool result;
SWIG_check_num_args("lldb::SBTarget::RemoveModule",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::RemoveModule",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::RemoveModule",2,"lldb::SBModule");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_RemoveModule",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBTarget_RemoveModule",2,SWIGTYPE_p_lldb__SBModule);
}
arg2 = *argp2;
result = (bool)(arg1)->RemoveModule(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetDebugger(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBDebugger result;
SWIG_check_num_args("lldb::SBTarget::GetDebugger",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetDebugger",1,"lldb::SBTarget const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetDebugger",1,SWIGTYPE_p_lldb__SBTarget);
}
result = ((lldb::SBTarget const *)arg1)->GetDebugger();
{
lldb::SBDebugger * resultptr = new lldb::SBDebugger((const lldb::SBDebugger &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBDebugger,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_FindModule(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
lldb::SBModule result;
SWIG_check_num_args("lldb::SBTarget::FindModule",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindModule",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::FindModule",2,"lldb::SBFileSpec const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_FindModule",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBTarget_FindModule",2,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (arg1)->FindModule((lldb::SBFileSpec const &)*arg2);
{
lldb::SBModule * resultptr = new lldb::SBModule((const lldb::SBModule &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_FindCompileUnits(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
lldb::SBSymbolContextList result;
SWIG_check_num_args("lldb::SBTarget::FindCompileUnits",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindCompileUnits",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::FindCompileUnits",2,"lldb::SBFileSpec const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_FindCompileUnits",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBTarget_FindCompileUnits",2,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (arg1)->FindCompileUnits((lldb::SBFileSpec const &)*arg2);
{
lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList((const lldb::SBSymbolContextList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetByteOrder(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::ByteOrder result;
SWIG_check_num_args("lldb::SBTarget::GetByteOrder",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetByteOrder",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetByteOrder",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (lldb::ByteOrder)(arg1)->GetByteOrder();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetAddressByteSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTarget::GetAddressByteSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetAddressByteSize",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetAddressByteSize",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (uint32_t)(arg1)->GetAddressByteSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetTriple(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBTarget::GetTriple",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetTriple",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetTriple",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (char *)(arg1)->GetTriple();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetDataByteSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTarget::GetDataByteSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetDataByteSize",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetDataByteSize",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (uint32_t)(arg1)->GetDataByteSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetCodeByteSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTarget::GetCodeByteSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetCodeByteSize",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetCodeByteSize",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (uint32_t)(arg1)->GetCodeByteSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetMaximumNumberOfChildrenToDisplay(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTarget::GetMaximumNumberOfChildrenToDisplay",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetMaximumNumberOfChildrenToDisplay",1,"lldb::SBTarget const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetMaximumNumberOfChildrenToDisplay",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (uint32_t)((lldb::SBTarget const *)arg1)->GetMaximumNumberOfChildrenToDisplay();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_SetSectionLoadAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBSection arg2 ;
lldb::addr_t arg3 ;
lldb::SBSection *argp2 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBTarget::SetSectionLoadAddress",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::SetSectionLoadAddress",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::SetSectionLoadAddress",2,"lldb::SBSection");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::SetSectionLoadAddress",3,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_SetSectionLoadAddress",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBTarget_SetSectionLoadAddress",2,SWIGTYPE_p_lldb__SBSection);
}
arg2 = *argp2;
arg3 = (lldb::addr_t)lua_tointeger(L, 3);
result = (arg1)->SetSectionLoadAddress(arg2,arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_ClearSectionLoadAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBSection arg2 ;
lldb::SBSection *argp2 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBTarget::ClearSectionLoadAddress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ClearSectionLoadAddress",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::ClearSectionLoadAddress",2,"lldb::SBSection");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_ClearSectionLoadAddress",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBSection,0))){
SWIG_fail_ptr("SBTarget_ClearSectionLoadAddress",2,SWIGTYPE_p_lldb__SBSection);
}
arg2 = *argp2;
result = (arg1)->ClearSectionLoadAddress(arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_SetModuleLoadAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBModule arg2 ;
int64_t arg3 ;
lldb::SBModule *argp2 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBTarget::SetModuleLoadAddress",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::SetModuleLoadAddress",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::SetModuleLoadAddress",2,"lldb::SBModule");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::SetModuleLoadAddress",3,"int64_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_SetModuleLoadAddress",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBTarget_SetModuleLoadAddress",2,SWIGTYPE_p_lldb__SBModule);
}
arg2 = *argp2;
arg3 = (int64_t)lua_tointeger(L, 3);
result = (arg1)->SetModuleLoadAddress(arg2,arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_ClearModuleLoadAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBModule arg2 ;
lldb::SBModule *argp2 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBTarget::ClearModuleLoadAddress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ClearModuleLoadAddress",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::ClearModuleLoadAddress",2,"lldb::SBModule");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_ClearModuleLoadAddress",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBTarget_ClearModuleLoadAddress",2,SWIGTYPE_p_lldb__SBModule);
}
arg2 = *argp2;
result = (arg1)->ClearModuleLoadAddress(arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_FindFunctions__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
uint32_t arg3 ;
lldb::SBSymbolContextList result;
SWIG_check_num_args("lldb::SBTarget::FindFunctions",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindFunctions",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindFunctions",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::FindFunctions",3,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_FindFunctions",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
result = (arg1)->FindFunctions((char const *)arg2,arg3);
{
lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList((const lldb::SBSymbolContextList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_FindFunctions__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBSymbolContextList result;
SWIG_check_num_args("lldb::SBTarget::FindFunctions",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindFunctions",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindFunctions",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_FindFunctions",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->FindFunctions((char const *)arg2);
{
lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList((const lldb::SBSymbolContextList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_FindFunctions(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBTarget_FindFunctions__SWIG_1(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBTarget_FindFunctions__SWIG_0(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTarget_FindFunctions'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTarget::FindFunctions(char const *,uint32_t)\n"
" lldb::SBTarget::FindFunctions(char const *)\n");
lua_error(L);return 0;
}
static int _wrap_SBTarget_FindFirstType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBTarget::FindFirstType",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindFirstType",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindFirstType",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_FindFirstType",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->FindFirstType((char const *)arg2);
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_FindTypes(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBTypeList result;
SWIG_check_num_args("lldb::SBTarget::FindTypes",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindTypes",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindTypes",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_FindTypes",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->FindTypes((char const *)arg2);
{
lldb::SBTypeList * resultptr = new lldb::SBTypeList((const lldb::SBTypeList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetBasicType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::BasicType arg2 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBTarget::GetBasicType",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetBasicType",1,"lldb::SBTarget *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::GetBasicType",2,"lldb::BasicType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetBasicType",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (lldb::BasicType)lua_tointeger(L, 2);
result = (arg1)->GetBasicType(arg2);
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetSourceManager(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
SwigValueWrapper< lldb::SBSourceManager > result;
SWIG_check_num_args("lldb::SBTarget::GetSourceManager",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetSourceManager",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetSourceManager",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (arg1)->GetSourceManager();
{
lldb::SBSourceManager * resultptr = new lldb::SBSourceManager((const lldb::SBSourceManager &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSourceManager,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_FindGlobalVariables__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
uint32_t arg3 ;
lldb::SBValueList result;
SWIG_check_num_args("lldb::SBTarget::FindGlobalVariables",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindGlobalVariables",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindGlobalVariables",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::FindGlobalVariables",3,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_FindGlobalVariables",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
result = (arg1)->FindGlobalVariables((char const *)arg2,arg3);
{
lldb::SBValueList * resultptr = new lldb::SBValueList((const lldb::SBValueList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_FindFirstGlobalVariable(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBTarget::FindFirstGlobalVariable",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindFirstGlobalVariable",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindFirstGlobalVariable",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_FindFirstGlobalVariable",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->FindFirstGlobalVariable((char const *)arg2);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_FindGlobalVariables__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
uint32_t arg3 ;
lldb::MatchType arg4 ;
lldb::SBValueList result;
SWIG_check_num_args("lldb::SBTarget::FindGlobalVariables",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindGlobalVariables",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindGlobalVariables",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::FindGlobalVariables",3,"uint32_t");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::FindGlobalVariables",4,"lldb::MatchType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_FindGlobalVariables",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
arg4 = (lldb::MatchType)lua_tointeger(L, 4);
result = (arg1)->FindGlobalVariables((char const *)arg2,arg3,arg4);
{
lldb::SBValueList * resultptr = new lldb::SBValueList((const lldb::SBValueList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_FindGlobalVariables(lua_State* L) {
int argc;
int argv[5]={
1,2,3,4,5
};
argc = lua_gettop(L);
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBTarget_FindGlobalVariables__SWIG_0(L);
}
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[3]);
}
if (_v) {
return _wrap_SBTarget_FindGlobalVariables__SWIG_1(L);
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTarget_FindGlobalVariables'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTarget::FindGlobalVariables(char const *,uint32_t)\n"
" lldb::SBTarget::FindGlobalVariables(char const *,uint32_t,lldb::MatchType)\n");
lua_error(L);return 0;
}
static int _wrap_SBTarget_FindGlobalFunctions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
uint32_t arg3 ;
lldb::MatchType arg4 ;
lldb::SBSymbolContextList result;
SWIG_check_num_args("lldb::SBTarget::FindGlobalFunctions",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindGlobalFunctions",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindGlobalFunctions",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::FindGlobalFunctions",3,"uint32_t");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::FindGlobalFunctions",4,"lldb::MatchType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_FindGlobalFunctions",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
arg4 = (lldb::MatchType)lua_tointeger(L, 4);
result = (arg1)->FindGlobalFunctions((char const *)arg2,arg3,arg4);
{
lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList((const lldb::SBSymbolContextList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
SWIG_check_num_args("lldb::SBTarget::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::Clear",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_Clear",1,SWIGTYPE_p_lldb__SBTarget);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_ResolveFileAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::addr_t arg2 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBTarget::ResolveFileAddress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ResolveFileAddress",1,"lldb::SBTarget *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::ResolveFileAddress",2,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_ResolveFileAddress",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
result = (arg1)->ResolveFileAddress(arg2);
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_ResolveLoadAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::addr_t arg2 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBTarget::ResolveLoadAddress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ResolveLoadAddress",1,"lldb::SBTarget *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::ResolveLoadAddress",2,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_ResolveLoadAddress",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
result = (arg1)->ResolveLoadAddress(arg2);
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_ResolvePastLoadAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
uint32_t arg2 ;
lldb::addr_t arg3 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBTarget::ResolvePastLoadAddress",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ResolvePastLoadAddress",1,"lldb::SBTarget *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::ResolvePastLoadAddress",2,"uint32_t");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::ResolvePastLoadAddress",3,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_ResolvePastLoadAddress",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
arg3 = (lldb::addr_t)lua_tointeger(L, 3);
result = (arg1)->ResolvePastLoadAddress(arg2,arg3);
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_ResolveSymbolContextForAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBAddress *arg2 = 0 ;
uint32_t arg3 ;
lldb::SBSymbolContext result;
SWIG_check_num_args("lldb::SBTarget::ResolveSymbolContextForAddress",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ResolveSymbolContextForAddress",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::ResolveSymbolContextForAddress",2,"lldb::SBAddress const &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::ResolveSymbolContextForAddress",3,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_ResolveSymbolContextForAddress",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBTarget_ResolveSymbolContextForAddress",2,SWIGTYPE_p_lldb__SBAddress);
}
arg3 = (uint32_t)lua_tointeger(L, 3);
result = (arg1)->ResolveSymbolContextForAddress((lldb::SBAddress const &)*arg2,arg3);
{
lldb::SBSymbolContext * resultptr = new lldb::SBSymbolContext((const lldb::SBSymbolContext &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContext,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_ReadMemory(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBAddress arg2 ;
void *arg3 = (void *) 0 ;
size_t arg4 ;
lldb::SBError *arg5 = 0 ;
lldb::SBAddress *argp2 ;
size_t result;
SWIG_check_num_args("lldb::SBTarget::ReadMemory",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ReadMemory",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::ReadMemory",2,"lldb::SBAddress const");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::ReadMemory",4,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_ReadMemory",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBTarget_ReadMemory",2,SWIGTYPE_p_lldb__SBAddress);
}
arg2 = *argp2;
{
arg4 = luaL_checkinteger(L, 3);
if (arg4 <= 0) {
return luaL_error(L, "Positive integer expected");
}
arg3 = (char *)malloc(arg4);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBTarget_ReadMemory",5,SWIGTYPE_p_lldb__SBError);
}
result = (arg1)->ReadMemory(arg2,arg3,arg4,*arg5);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
{
lua_pop(L, 1); // Blow away the previous result
if (result == 0) {
lua_pushliteral(L, "");
} else {
lua_pushlstring(L, (const char *)arg3, result);
}
free(arg3);
// SWIG_arg was already incremented
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateByLocation__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
uint32_t arg3 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByLocation",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",3,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
result = (arg1)->BreakpointCreateByLocation((char const *)arg2,arg3);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateByLocation__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
uint32_t arg3 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByLocation",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",2,"lldb::SBFileSpec const &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",3,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",2,SWIGTYPE_p_lldb__SBFileSpec);
}
arg3 = (uint32_t)lua_tointeger(L, 3);
result = (arg1)->BreakpointCreateByLocation((lldb::SBFileSpec const &)*arg2,arg3);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateByLocation__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
uint32_t arg3 ;
lldb::addr_t arg4 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByLocation",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",2,"lldb::SBFileSpec const &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",3,"uint32_t");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",4,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",2,SWIGTYPE_p_lldb__SBFileSpec);
}
arg3 = (uint32_t)lua_tointeger(L, 3);
arg4 = (lldb::addr_t)lua_tointeger(L, 4);
result = (arg1)->BreakpointCreateByLocation((lldb::SBFileSpec const &)*arg2,arg3,arg4);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateByLocation__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
uint32_t arg3 ;
lldb::addr_t arg4 ;
lldb::SBFileSpecList *arg5 = 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByLocation",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",2,"lldb::SBFileSpec const &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",3,"uint32_t");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",4,"lldb::addr_t");
if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",5,"lldb::SBFileSpecList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",2,SWIGTYPE_p_lldb__SBFileSpec);
}
arg3 = (uint32_t)lua_tointeger(L, 3);
arg4 = (lldb::addr_t)lua_tointeger(L, 4);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",5,SWIGTYPE_p_lldb__SBFileSpecList);
}
result = (arg1)->BreakpointCreateByLocation((lldb::SBFileSpec const &)*arg2,arg3,arg4,*arg5);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateByLocation__SWIG_4(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
uint32_t arg3 ;
uint32_t arg4 ;
lldb::addr_t arg5 ;
lldb::SBFileSpecList *arg6 = 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByLocation",6,6)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",2,"lldb::SBFileSpec const &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",3,"uint32_t");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",4,"uint32_t");
if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",5,"lldb::addr_t");
if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",6,"lldb::SBFileSpecList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",2,SWIGTYPE_p_lldb__SBFileSpec);
}
arg3 = (uint32_t)lua_tointeger(L, 3);
arg4 = (uint32_t)lua_tointeger(L, 4);
arg5 = (lldb::addr_t)lua_tointeger(L, 5);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",6,SWIGTYPE_p_lldb__SBFileSpecList);
}
result = (arg1)->BreakpointCreateByLocation((lldb::SBFileSpec const &)*arg2,arg3,arg4,arg5,*arg6);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateByLocation__SWIG_5(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
uint32_t arg3 ;
uint32_t arg4 ;
lldb::addr_t arg5 ;
lldb::SBFileSpecList *arg6 = 0 ;
bool arg7 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByLocation",7,7)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",2,"lldb::SBFileSpec const &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",3,"uint32_t");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",4,"uint32_t");
if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",5,"lldb::addr_t");
if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",6,"lldb::SBFileSpecList &");
if(!lua_isboolean(L,7)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",7,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",2,SWIGTYPE_p_lldb__SBFileSpec);
}
arg3 = (uint32_t)lua_tointeger(L, 3);
arg4 = (uint32_t)lua_tointeger(L, 4);
arg5 = (lldb::addr_t)lua_tointeger(L, 5);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",6,SWIGTYPE_p_lldb__SBFileSpecList);
}
arg7 = (lua_toboolean(L, 7)!=0);
result = (arg1)->BreakpointCreateByLocation((lldb::SBFileSpec const &)*arg2,arg3,arg4,arg5,*arg6,arg7);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateByLocation(lua_State* L) {
int argc;
int argv[8]={
1,2,3,4,5,6,7,8
};
argc = lua_gettop(L);
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateByLocation__SWIG_1(L);
}
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateByLocation__SWIG_0(L);
}
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[3]);
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateByLocation__SWIG_2(L);
}
}
}
}
}
if (argc == 5) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[3]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateByLocation__SWIG_3(L);
}
}
}
}
}
}
if (argc == 6) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[3]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[4]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateByLocation__SWIG_4(L);
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[3]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[4]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[6]);
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateByLocation__SWIG_5(L);
}
}
}
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTarget_BreakpointCreateByLocation'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTarget::BreakpointCreateByLocation(char const *,uint32_t)\n"
" lldb::SBTarget::BreakpointCreateByLocation(lldb::SBFileSpec const &,uint32_t)\n"
" lldb::SBTarget::BreakpointCreateByLocation(lldb::SBFileSpec const &,uint32_t,lldb::addr_t)\n"
" lldb::SBTarget::BreakpointCreateByLocation(lldb::SBFileSpec const &,uint32_t,lldb::addr_t,lldb::SBFileSpecList &)\n"
" lldb::SBTarget::BreakpointCreateByLocation(lldb::SBFileSpec const &,uint32_t,uint32_t,lldb::addr_t,lldb::SBFileSpecList &)\n"
" lldb::SBTarget::BreakpointCreateByLocation(lldb::SBFileSpec const &,uint32_t,uint32_t,lldb::addr_t,lldb::SBFileSpecList &,bool)\n");
lua_error(L);return 0;
}
static int _wrap_SBTarget_BreakpointCreateByName__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByName",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",2,"char const *");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",3,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByName",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (char *)lua_tostring(L, 3);
result = (arg1)->BreakpointCreateByName((char const *)arg2,(char const *)arg3);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateByName__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByName",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->BreakpointCreateByName((char const *)arg2);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateByName__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
uint32_t arg3 ;
lldb::SBFileSpecList *arg4 = 0 ;
lldb::SBFileSpecList *arg5 = 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByName",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",3,"uint32_t");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",4,"lldb::SBFileSpecList const &");
if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",5,"lldb::SBFileSpecList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByName",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByName",4,SWIGTYPE_p_lldb__SBFileSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByName",5,SWIGTYPE_p_lldb__SBFileSpecList);
}
result = (arg1)->BreakpointCreateByName((char const *)arg2,arg3,(lldb::SBFileSpecList const &)*arg4,(lldb::SBFileSpecList const &)*arg5);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateByName__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
uint32_t arg3 ;
lldb::LanguageType arg4 ;
lldb::SBFileSpecList *arg5 = 0 ;
lldb::SBFileSpecList *arg6 = 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByName",6,6)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",3,"uint32_t");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",4,"lldb::LanguageType");
if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",5,"lldb::SBFileSpecList const &");
if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",6,"lldb::SBFileSpecList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByName",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
arg4 = (lldb::LanguageType)lua_tointeger(L, 4);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByName",5,SWIGTYPE_p_lldb__SBFileSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByName",6,SWIGTYPE_p_lldb__SBFileSpecList);
}
result = (arg1)->BreakpointCreateByName((char const *)arg2,arg3,arg4,(lldb::SBFileSpecList const &)*arg5,(lldb::SBFileSpecList const &)*arg6);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateByName(lua_State* L) {
int argc;
int argv[7]={
1,2,3,4,5,6,7
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateByName__SWIG_1(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[2]);
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateByName__SWIG_0(L);
}
}
}
}
if (argc == 5) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateByName__SWIG_2(L);
}
}
}
}
}
}
if (argc == 6) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[3]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateByName__SWIG_3(L);
}
}
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTarget_BreakpointCreateByName'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTarget::BreakpointCreateByName(char const *,char const *)\n"
" lldb::SBTarget::BreakpointCreateByName(char const *)\n"
" lldb::SBTarget::BreakpointCreateByName(char const *,uint32_t,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n"
" lldb::SBTarget::BreakpointCreateByName(char const *,uint32_t,lldb::LanguageType,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTarget_BreakpointCreateByNames__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char **arg2 = (char **) 0 ;
uint32_t arg3 ;
uint32_t arg4 ;
lldb::SBFileSpecList *arg5 = 0 ;
lldb::SBFileSpecList *arg6 = 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByNames",6,6)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",1,"lldb::SBTarget *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",3,"uint32_t");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",4,"uint32_t");
if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",5,"lldb::SBFileSpecList const &");
if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",6,"lldb::SBFileSpecList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByNames",1,SWIGTYPE_p_lldb__SBTarget);
}
{
if (lua_istable(L, 2)) {
size_t size = lua_rawlen(L, 2);
arg2 = (char **)malloc((size + 1) * sizeof(char *));
int i = 0, j = 0;
while (i++ < size) {
lua_rawgeti(L, 2, i);
if (!lua_isstring(L, -1)) {
// if current element cannot be converted to string, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain strings");
}
arg2[j++] = (char *)lua_tostring(L, -1);
lua_pop(L, 1);
}
arg2[j] = 0;
} else if (lua_isnil(L, 2)) {
// "nil" is also acceptable, equivalent as an empty table
arg2 = NULL;
} else {
return luaL_error(L, "A list of strings expected");
}
}
arg3 = (uint32_t)lua_tointeger(L, 3);
arg4 = (uint32_t)lua_tointeger(L, 4);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByNames",5,SWIGTYPE_p_lldb__SBFileSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByNames",6,SWIGTYPE_p_lldb__SBFileSpecList);
}
result = (arg1)->BreakpointCreateByNames((char const **)arg2,arg3,arg4,(lldb::SBFileSpecList const &)*arg5,(lldb::SBFileSpecList const &)*arg6);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
{
free((char *) arg2);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free((char *) arg2);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateByNames__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char **arg2 = (char **) 0 ;
uint32_t arg3 ;
uint32_t arg4 ;
lldb::LanguageType arg5 ;
lldb::SBFileSpecList *arg6 = 0 ;
lldb::SBFileSpecList *arg7 = 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByNames",7,7)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",1,"lldb::SBTarget *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",3,"uint32_t");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",4,"uint32_t");
if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",5,"lldb::LanguageType");
if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",6,"lldb::SBFileSpecList const &");
if(!lua_isuserdata(L,7)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",7,"lldb::SBFileSpecList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByNames",1,SWIGTYPE_p_lldb__SBTarget);
}
{
if (lua_istable(L, 2)) {
size_t size = lua_rawlen(L, 2);
arg2 = (char **)malloc((size + 1) * sizeof(char *));
int i = 0, j = 0;
while (i++ < size) {
lua_rawgeti(L, 2, i);
if (!lua_isstring(L, -1)) {
// if current element cannot be converted to string, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain strings");
}
arg2[j++] = (char *)lua_tostring(L, -1);
lua_pop(L, 1);
}
arg2[j] = 0;
} else if (lua_isnil(L, 2)) {
// "nil" is also acceptable, equivalent as an empty table
arg2 = NULL;
} else {
return luaL_error(L, "A list of strings expected");
}
}
arg3 = (uint32_t)lua_tointeger(L, 3);
arg4 = (uint32_t)lua_tointeger(L, 4);
arg5 = (lldb::LanguageType)lua_tointeger(L, 5);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByNames",6,SWIGTYPE_p_lldb__SBFileSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByNames",7,SWIGTYPE_p_lldb__SBFileSpecList);
}
result = (arg1)->BreakpointCreateByNames((char const **)arg2,arg3,arg4,arg5,(lldb::SBFileSpecList const &)*arg6,(lldb::SBFileSpecList const &)*arg7);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
{
free((char *) arg2);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free((char *) arg2);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateByNames__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char **arg2 = (char **) 0 ;
uint32_t arg3 ;
uint32_t arg4 ;
lldb::LanguageType arg5 ;
lldb::addr_t arg6 ;
lldb::SBFileSpecList *arg7 = 0 ;
lldb::SBFileSpecList *arg8 = 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByNames",8,8)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",1,"lldb::SBTarget *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",3,"uint32_t");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",4,"uint32_t");
if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",5,"lldb::LanguageType");
if(!lua_isinteger(L,6)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",6,"lldb::addr_t");
if(!lua_isuserdata(L,7)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",7,"lldb::SBFileSpecList const &");
if(!lua_isuserdata(L,8)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",8,"lldb::SBFileSpecList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByNames",1,SWIGTYPE_p_lldb__SBTarget);
}
{
if (lua_istable(L, 2)) {
size_t size = lua_rawlen(L, 2);
arg2 = (char **)malloc((size + 1) * sizeof(char *));
int i = 0, j = 0;
while (i++ < size) {
lua_rawgeti(L, 2, i);
if (!lua_isstring(L, -1)) {
// if current element cannot be converted to string, raise an error
lua_pop(L, 1);
return luaL_error(L, "List should only contain strings");
}
arg2[j++] = (char *)lua_tostring(L, -1);
lua_pop(L, 1);
}
arg2[j] = 0;
} else if (lua_isnil(L, 2)) {
// "nil" is also acceptable, equivalent as an empty table
arg2 = NULL;
} else {
return luaL_error(L, "A list of strings expected");
}
}
arg3 = (uint32_t)lua_tointeger(L, 3);
arg4 = (uint32_t)lua_tointeger(L, 4);
arg5 = (lldb::LanguageType)lua_tointeger(L, 5);
arg6 = (lldb::addr_t)lua_tointeger(L, 6);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByNames",7,SWIGTYPE_p_lldb__SBFileSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,8,(void**)&arg8,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByNames",8,SWIGTYPE_p_lldb__SBFileSpecList);
}
result = (arg1)->BreakpointCreateByNames((char const **)arg2,arg3,arg4,arg5,arg6,(lldb::SBFileSpecList const &)*arg7,(lldb::SBFileSpecList const &)*arg8);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
{
free((char *) arg2);
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
{
free((char *) arg2);
}
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateByNames(lua_State* L) {
int argc;
int argv[9]={
1,2,3,4,5,6,7,8,9
};
argc = lua_gettop(L);
if (argc == 6) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_istable(L, argv[1]) || lua_isnil(L, argv[1]));
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[3]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateByNames__SWIG_0(L);
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_istable(L, argv[1]) || lua_isnil(L, argv[1]));
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[3]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[4]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[6])==0 || SWIG_ConvertPtr(L,argv[6], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateByNames__SWIG_1(L);
}
}
}
}
}
}
}
}
if (argc == 8) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = (lua_istable(L, argv[1]) || lua_isnil(L, argv[1]));
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[3]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[4]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[5]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[6])==0 || SWIG_ConvertPtr(L,argv[6], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[7])==0 || SWIG_ConvertPtr(L,argv[7], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateByNames__SWIG_2(L);
}
}
}
}
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTarget_BreakpointCreateByNames'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTarget::BreakpointCreateByNames(char const **,uint32_t,uint32_t,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n"
" lldb::SBTarget::BreakpointCreateByNames(char const **,uint32_t,uint32_t,lldb::LanguageType,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n"
" lldb::SBTarget::BreakpointCreateByNames(char const **,uint32_t,uint32_t,lldb::LanguageType,lldb::addr_t,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTarget_BreakpointCreateByRegex__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByRegex",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",2,"char const *");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",3,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByRegex",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (char *)lua_tostring(L, 3);
result = (arg1)->BreakpointCreateByRegex((char const *)arg2,(char const *)arg3);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateByRegex__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByRegex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByRegex",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->BreakpointCreateByRegex((char const *)arg2);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateByRegex__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::LanguageType arg3 ;
lldb::SBFileSpecList *arg4 = 0 ;
lldb::SBFileSpecList *arg5 = 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByRegex",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",3,"lldb::LanguageType");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",4,"lldb::SBFileSpecList const &");
if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",5,"lldb::SBFileSpecList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByRegex",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (lldb::LanguageType)lua_tointeger(L, 3);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByRegex",4,SWIGTYPE_p_lldb__SBFileSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByRegex",5,SWIGTYPE_p_lldb__SBFileSpecList);
}
result = (arg1)->BreakpointCreateByRegex((char const *)arg2,arg3,(lldb::SBFileSpecList const &)*arg4,(lldb::SBFileSpecList const &)*arg5);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateByRegex(lua_State* L) {
int argc;
int argv[6]={
1,2,3,4,5,6
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateByRegex__SWIG_1(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[2]);
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateByRegex__SWIG_0(L);
}
}
}
}
if (argc == 5) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateByRegex__SWIG_2(L);
}
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTarget_BreakpointCreateByRegex'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTarget::BreakpointCreateByRegex(char const *,char const *)\n"
" lldb::SBTarget::BreakpointCreateByRegex(char const *)\n"
" lldb::SBTarget::BreakpointCreateByRegex(char const *,lldb::LanguageType,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBFileSpec *arg3 = 0 ;
char *arg4 = (char *) 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateBySourceRegex",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",3,"lldb::SBFileSpec const &");
if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",4,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",3,SWIGTYPE_p_lldb__SBFileSpec);
}
arg4 = (char *)lua_tostring(L, 4);
result = (arg1)->BreakpointCreateBySourceRegex((char const *)arg2,(lldb::SBFileSpec const &)*arg3,(char const *)arg4);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBFileSpec *arg3 = 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateBySourceRegex",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",3,"lldb::SBFileSpec const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",3,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (arg1)->BreakpointCreateBySourceRegex((char const *)arg2,(lldb::SBFileSpec const &)*arg3);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBFileSpecList *arg3 = 0 ;
lldb::SBFileSpecList *arg4 = 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateBySourceRegex",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",3,"lldb::SBFileSpecList const &");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",4,"lldb::SBFileSpecList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",3,SWIGTYPE_p_lldb__SBFileSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",4,SWIGTYPE_p_lldb__SBFileSpecList);
}
result = (arg1)->BreakpointCreateBySourceRegex((char const *)arg2,(lldb::SBFileSpecList const &)*arg3,(lldb::SBFileSpecList const &)*arg4);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBFileSpecList *arg3 = 0 ;
lldb::SBFileSpecList *arg4 = 0 ;
lldb::SBStringList *arg5 = 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateBySourceRegex",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",3,"lldb::SBFileSpecList const &");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",4,"lldb::SBFileSpecList const &");
if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",5,"lldb::SBStringList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",3,SWIGTYPE_p_lldb__SBFileSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",4,SWIGTYPE_p_lldb__SBFileSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",5,SWIGTYPE_p_lldb__SBStringList);
}
result = (arg1)->BreakpointCreateBySourceRegex((char const *)arg2,(lldb::SBFileSpecList const &)*arg3,(lldb::SBFileSpecList const &)*arg4,(lldb::SBStringList const &)*arg5);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateBySourceRegex(lua_State* L) {
int argc;
int argv[6]={
1,2,3,4,5,6
};
argc = lua_gettop(L);
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_1(L);
}
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[3]);
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_0(L);
}
}
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_2(L);
}
}
}
}
}
if (argc == 5) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBStringList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_3(L);
}
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTarget_BreakpointCreateBySourceRegex'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTarget::BreakpointCreateBySourceRegex(char const *,lldb::SBFileSpec const &,char const *)\n"
" lldb::SBTarget::BreakpointCreateBySourceRegex(char const *,lldb::SBFileSpec const &)\n"
" lldb::SBTarget::BreakpointCreateBySourceRegex(char const *,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n"
" lldb::SBTarget::BreakpointCreateBySourceRegex(char const *,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &,lldb::SBStringList const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTarget_BreakpointCreateForException(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::LanguageType arg2 ;
bool arg3 ;
bool arg4 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateForException",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateForException",1,"lldb::SBTarget *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateForException",2,"lldb::LanguageType");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateForException",3,"bool");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateForException",4,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateForException",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (lldb::LanguageType)lua_tointeger(L, 2);
arg3 = (lua_toboolean(L, 3)!=0);
arg4 = (lua_toboolean(L, 4)!=0);
result = (arg1)->BreakpointCreateForException(arg2,arg3,arg4);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateByAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::addr_t arg2 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByAddress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByAddress",1,"lldb::SBTarget *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByAddress",2,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateByAddress",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
result = (arg1)->BreakpointCreateByAddress(arg2);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetEnvironment(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBEnvironment result;
SWIG_check_num_args("lldb::SBTarget::GetEnvironment",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetEnvironment",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetEnvironment",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (arg1)->GetEnvironment();
{
lldb::SBEnvironment * resultptr = new lldb::SBEnvironment((const lldb::SBEnvironment &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBEnvironment,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateBySBAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBAddress *arg2 = 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateBySBAddress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySBAddress",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySBAddress",2,"lldb::SBAddress &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateBySBAddress",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateBySBAddress",2,SWIGTYPE_p_lldb__SBAddress);
}
result = (arg1)->BreakpointCreateBySBAddress(*arg2);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateFromScript__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBStructuredData *arg3 = 0 ;
lldb::SBFileSpecList *arg4 = 0 ;
lldb::SBFileSpecList *arg5 = 0 ;
bool arg6 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateFromScript",6,6)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",3,"lldb::SBStructuredData &");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",4,"lldb::SBFileSpecList const &");
if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",5,"lldb::SBFileSpecList const &");
if(!lua_isboolean(L,6)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",6,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateFromScript",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateFromScript",3,SWIGTYPE_p_lldb__SBStructuredData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateFromScript",4,SWIGTYPE_p_lldb__SBFileSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateFromScript",5,SWIGTYPE_p_lldb__SBFileSpecList);
}
arg6 = (lua_toboolean(L, 6)!=0);
result = (arg1)->BreakpointCreateFromScript((char const *)arg2,*arg3,(lldb::SBFileSpecList const &)*arg4,(lldb::SBFileSpecList const &)*arg5,arg6);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateFromScript__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBStructuredData *arg3 = 0 ;
lldb::SBFileSpecList *arg4 = 0 ;
lldb::SBFileSpecList *arg5 = 0 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::BreakpointCreateFromScript",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",3,"lldb::SBStructuredData &");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",4,"lldb::SBFileSpecList const &");
if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",5,"lldb::SBFileSpecList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateFromScript",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateFromScript",3,SWIGTYPE_p_lldb__SBStructuredData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateFromScript",4,SWIGTYPE_p_lldb__SBFileSpecList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBFileSpecList,0))){
SWIG_fail_ptr("SBTarget_BreakpointCreateFromScript",5,SWIGTYPE_p_lldb__SBFileSpecList);
}
result = (arg1)->BreakpointCreateFromScript((char const *)arg2,*arg3,(lldb::SBFileSpecList const &)*arg4,(lldb::SBFileSpecList const &)*arg5);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointCreateFromScript(lua_State* L) {
int argc;
int argv[7]={
1,2,3,4,5,6,7
};
argc = lua_gettop(L);
if (argc == 5) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateFromScript__SWIG_1(L);
}
}
}
}
}
}
if (argc == 6) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[5]);
}
if (_v) {
return _wrap_SBTarget_BreakpointCreateFromScript__SWIG_0(L);
}
}
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTarget_BreakpointCreateFromScript'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTarget::BreakpointCreateFromScript(char const *,lldb::SBStructuredData &,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &,bool)\n"
" lldb::SBTarget::BreakpointCreateFromScript(char const *,lldb::SBStructuredData &,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTarget_GetNumBreakpoints(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTarget::GetNumBreakpoints",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetNumBreakpoints",1,"lldb::SBTarget const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetNumBreakpoints",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (uint32_t)((lldb::SBTarget const *)arg1)->GetNumBreakpoints();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetBreakpointAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
uint32_t arg2 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::GetBreakpointAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetBreakpointAtIndex",1,"lldb::SBTarget const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::GetBreakpointAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetBreakpointAtIndex",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = ((lldb::SBTarget const *)arg1)->GetBreakpointAtIndex(arg2);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointDelete(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::break_id_t arg2 ;
bool result;
SWIG_check_num_args("lldb::SBTarget::BreakpointDelete",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointDelete",1,"lldb::SBTarget *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointDelete",2,"lldb::break_id_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointDelete",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (lldb::break_id_t)lua_tointeger(L, 2);
result = (bool)(arg1)->BreakpointDelete(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_FindBreakpointByID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::break_id_t arg2 ;
lldb::SBBreakpoint result;
SWIG_check_num_args("lldb::SBTarget::FindBreakpointByID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindBreakpointByID",1,"lldb::SBTarget *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::FindBreakpointByID",2,"lldb::break_id_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_FindBreakpointByID",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (lldb::break_id_t)lua_tointeger(L, 2);
result = (arg1)->FindBreakpointByID(arg2);
{
lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint((const lldb::SBBreakpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_FindBreakpointsByName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBBreakpointList *arg3 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBTarget::FindBreakpointsByName",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindBreakpointsByName",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindBreakpointsByName",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::FindBreakpointsByName",3,"lldb::SBBreakpointList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_FindBreakpointsByName",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBBreakpointList,0))){
SWIG_fail_ptr("SBTarget_FindBreakpointsByName",3,SWIGTYPE_p_lldb__SBBreakpointList);
}
result = (bool)(arg1)->FindBreakpointsByName((char const *)arg2,*arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_DeleteBreakpointName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBTarget::DeleteBreakpointName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::DeleteBreakpointName",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::DeleteBreakpointName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_DeleteBreakpointName",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->DeleteBreakpointName((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetBreakpointNames(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBStringList *arg2 = 0 ;
SWIG_check_num_args("lldb::SBTarget::GetBreakpointNames",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetBreakpointNames",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::GetBreakpointNames",2,"lldb::SBStringList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetBreakpointNames",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBTarget_GetBreakpointNames",2,SWIGTYPE_p_lldb__SBStringList);
}
(arg1)->GetBreakpointNames(*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_EnableAllBreakpoints(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTarget::EnableAllBreakpoints",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::EnableAllBreakpoints",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_EnableAllBreakpoints",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (bool)(arg1)->EnableAllBreakpoints();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_DisableAllBreakpoints(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTarget::DisableAllBreakpoints",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::DisableAllBreakpoints",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_DisableAllBreakpoints",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (bool)(arg1)->DisableAllBreakpoints();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_DeleteAllBreakpoints(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTarget::DeleteAllBreakpoints",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::DeleteAllBreakpoints",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_DeleteAllBreakpoints",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (bool)(arg1)->DeleteAllBreakpoints();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointsCreateFromFile__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
lldb::SBBreakpointList *arg3 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBTarget::BreakpointsCreateFromFile",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointsCreateFromFile",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointsCreateFromFile",2,"lldb::SBFileSpec &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointsCreateFromFile",3,"lldb::SBBreakpointList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointsCreateFromFile",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBTarget_BreakpointsCreateFromFile",2,SWIGTYPE_p_lldb__SBFileSpec);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBBreakpointList,0))){
SWIG_fail_ptr("SBTarget_BreakpointsCreateFromFile",3,SWIGTYPE_p_lldb__SBBreakpointList);
}
result = (arg1)->BreakpointsCreateFromFile(*arg2,*arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointsCreateFromFile__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
lldb::SBStringList *arg3 = 0 ;
lldb::SBBreakpointList *arg4 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBTarget::BreakpointsCreateFromFile",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointsCreateFromFile",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointsCreateFromFile",2,"lldb::SBFileSpec &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointsCreateFromFile",3,"lldb::SBStringList &");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointsCreateFromFile",4,"lldb::SBBreakpointList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointsCreateFromFile",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBTarget_BreakpointsCreateFromFile",2,SWIGTYPE_p_lldb__SBFileSpec);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStringList,0))){
SWIG_fail_ptr("SBTarget_BreakpointsCreateFromFile",3,SWIGTYPE_p_lldb__SBStringList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBBreakpointList,0))){
SWIG_fail_ptr("SBTarget_BreakpointsCreateFromFile",4,SWIGTYPE_p_lldb__SBBreakpointList);
}
result = (arg1)->BreakpointsCreateFromFile(*arg2,*arg3,*arg4);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointsCreateFromFile(lua_State* L) {
int argc;
int argv[5]={
1,2,3,4,5
};
argc = lua_gettop(L);
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_BreakpointsCreateFromFile__SWIG_0(L);
}
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStringList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_BreakpointsCreateFromFile__SWIG_1(L);
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTarget_BreakpointsCreateFromFile'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTarget::BreakpointsCreateFromFile(lldb::SBFileSpec &,lldb::SBBreakpointList &)\n"
" lldb::SBTarget::BreakpointsCreateFromFile(lldb::SBFileSpec &,lldb::SBStringList &,lldb::SBBreakpointList &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTarget_BreakpointsWriteToFile__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBTarget::BreakpointsWriteToFile",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointsWriteToFile",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointsWriteToFile",2,"lldb::SBFileSpec &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointsWriteToFile",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBTarget_BreakpointsWriteToFile",2,SWIGTYPE_p_lldb__SBFileSpec);
}
result = (arg1)->BreakpointsWriteToFile(*arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointsWriteToFile__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
lldb::SBBreakpointList *arg3 = 0 ;
bool arg4 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBTarget::BreakpointsWriteToFile",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointsWriteToFile",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointsWriteToFile",2,"lldb::SBFileSpec &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointsWriteToFile",3,"lldb::SBBreakpointList &");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointsWriteToFile",4,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointsWriteToFile",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBTarget_BreakpointsWriteToFile",2,SWIGTYPE_p_lldb__SBFileSpec);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBBreakpointList,0))){
SWIG_fail_ptr("SBTarget_BreakpointsWriteToFile",3,SWIGTYPE_p_lldb__SBBreakpointList);
}
arg4 = (lua_toboolean(L, 4)!=0);
result = (arg1)->BreakpointsWriteToFile(*arg2,*arg3,arg4);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointsWriteToFile__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
lldb::SBBreakpointList *arg3 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBTarget::BreakpointsWriteToFile",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointsWriteToFile",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointsWriteToFile",2,"lldb::SBFileSpec &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointsWriteToFile",3,"lldb::SBBreakpointList &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_BreakpointsWriteToFile",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBTarget_BreakpointsWriteToFile",2,SWIGTYPE_p_lldb__SBFileSpec);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBBreakpointList,0))){
SWIG_fail_ptr("SBTarget_BreakpointsWriteToFile",3,SWIGTYPE_p_lldb__SBBreakpointList);
}
result = (arg1)->BreakpointsWriteToFile(*arg2,*arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_BreakpointsWriteToFile(lua_State* L) {
int argc;
int argv[5]={
1,2,3,4,5
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_BreakpointsWriteToFile__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_BreakpointsWriteToFile__SWIG_2(L);
}
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[3]);
}
if (_v) {
return _wrap_SBTarget_BreakpointsWriteToFile__SWIG_1(L);
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTarget_BreakpointsWriteToFile'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTarget::BreakpointsWriteToFile(lldb::SBFileSpec &)\n"
" lldb::SBTarget::BreakpointsWriteToFile(lldb::SBFileSpec &,lldb::SBBreakpointList &,bool)\n"
" lldb::SBTarget::BreakpointsWriteToFile(lldb::SBFileSpec &,lldb::SBBreakpointList &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTarget_GetNumWatchpoints(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTarget::GetNumWatchpoints",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetNumWatchpoints",1,"lldb::SBTarget const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetNumWatchpoints",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (uint32_t)((lldb::SBTarget const *)arg1)->GetNumWatchpoints();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetWatchpointAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
uint32_t arg2 ;
lldb::SBWatchpoint result;
SWIG_check_num_args("lldb::SBTarget::GetWatchpointAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetWatchpointAtIndex",1,"lldb::SBTarget const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::GetWatchpointAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetWatchpointAtIndex",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = ((lldb::SBTarget const *)arg1)->GetWatchpointAtIndex(arg2);
{
lldb::SBWatchpoint * resultptr = new lldb::SBWatchpoint((const lldb::SBWatchpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBWatchpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_DeleteWatchpoint(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::watch_id_t arg2 ;
bool result;
SWIG_check_num_args("lldb::SBTarget::DeleteWatchpoint",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::DeleteWatchpoint",1,"lldb::SBTarget *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::DeleteWatchpoint",2,"lldb::watch_id_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_DeleteWatchpoint",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (lldb::watch_id_t)lua_tointeger(L, 2);
result = (bool)(arg1)->DeleteWatchpoint(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_FindWatchpointByID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::watch_id_t arg2 ;
lldb::SBWatchpoint result;
SWIG_check_num_args("lldb::SBTarget::FindWatchpointByID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindWatchpointByID",1,"lldb::SBTarget *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::FindWatchpointByID",2,"lldb::watch_id_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_FindWatchpointByID",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (lldb::watch_id_t)lua_tointeger(L, 2);
result = (arg1)->FindWatchpointByID(arg2);
{
lldb::SBWatchpoint * resultptr = new lldb::SBWatchpoint((const lldb::SBWatchpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBWatchpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_EnableAllWatchpoints(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTarget::EnableAllWatchpoints",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::EnableAllWatchpoints",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_EnableAllWatchpoints",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (bool)(arg1)->EnableAllWatchpoints();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_DisableAllWatchpoints(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTarget::DisableAllWatchpoints",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::DisableAllWatchpoints",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_DisableAllWatchpoints",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (bool)(arg1)->DisableAllWatchpoints();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_DeleteAllWatchpoints(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTarget::DeleteAllWatchpoints",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::DeleteAllWatchpoints",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_DeleteAllWatchpoints",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (bool)(arg1)->DeleteAllWatchpoints();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_WatchAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::addr_t arg2 ;
size_t arg3 ;
bool arg4 ;
bool arg5 ;
lldb::SBError *arg6 = 0 ;
lldb::SBWatchpoint result;
SWIG_check_num_args("lldb::SBTarget::WatchAddress",6,6)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::WatchAddress",1,"lldb::SBTarget *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::WatchAddress",2,"lldb::addr_t");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::WatchAddress",3,"size_t");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBTarget::WatchAddress",4,"bool");
if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBTarget::WatchAddress",5,"bool");
if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBTarget::WatchAddress",6,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_WatchAddress",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
arg3 = (size_t)lua_tointeger(L, 3);
arg4 = (lua_toboolean(L, 4)!=0);
arg5 = (lua_toboolean(L, 5)!=0);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBTarget_WatchAddress",6,SWIGTYPE_p_lldb__SBError);
}
result = (arg1)->WatchAddress(arg2,arg3,arg4,arg5,*arg6);
{
lldb::SBWatchpoint * resultptr = new lldb::SBWatchpoint((const lldb::SBWatchpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBWatchpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetBroadcaster(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBBroadcaster result;
SWIG_check_num_args("lldb::SBTarget::GetBroadcaster",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetBroadcaster",1,"lldb::SBTarget const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetBroadcaster",1,SWIGTYPE_p_lldb__SBTarget);
}
result = ((lldb::SBTarget const *)arg1)->GetBroadcaster();
{
lldb::SBBroadcaster * resultptr = new lldb::SBBroadcaster((const lldb::SBBroadcaster &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBroadcaster,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_CreateValueFromAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBAddress arg3 ;
lldb::SBType arg4 ;
lldb::SBAddress *argp3 ;
lldb::SBType *argp4 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBTarget::CreateValueFromAddress",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromAddress",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromAddress",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromAddress",3,"lldb::SBAddress");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromAddress",4,"lldb::SBType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_CreateValueFromAddress",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBTarget_CreateValueFromAddress",3,SWIGTYPE_p_lldb__SBAddress);
}
arg3 = *argp3;
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBTarget_CreateValueFromAddress",4,SWIGTYPE_p_lldb__SBType);
}
arg4 = *argp4;
result = (arg1)->CreateValueFromAddress((char const *)arg2,arg3,arg4);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_CreateValueFromData(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBData arg3 ;
lldb::SBType arg4 ;
lldb::SBData *argp3 ;
lldb::SBType *argp4 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBTarget::CreateValueFromData",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromData",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromData",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromData",3,"lldb::SBData");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromData",4,"lldb::SBType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_CreateValueFromData",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBTarget_CreateValueFromData",3,SWIGTYPE_p_lldb__SBData);
}
arg3 = *argp3;
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBTarget_CreateValueFromData",4,SWIGTYPE_p_lldb__SBType);
}
arg4 = *argp4;
result = (arg1)->CreateValueFromData((char const *)arg2,arg3,arg4);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_CreateValueFromExpression(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBTarget::CreateValueFromExpression",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromExpression",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromExpression",2,"char const *");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromExpression",3,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_CreateValueFromExpression",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (char *)lua_tostring(L, 3);
result = (arg1)->CreateValueFromExpression((char const *)arg2,(char const *)arg3);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_ReadInstructions__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBAddress arg2 ;
uint32_t arg3 ;
lldb::SBAddress *argp2 ;
lldb::SBInstructionList result;
SWIG_check_num_args("lldb::SBTarget::ReadInstructions",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ReadInstructions",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::ReadInstructions",2,"lldb::SBAddress");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::ReadInstructions",3,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_ReadInstructions",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBTarget_ReadInstructions",2,SWIGTYPE_p_lldb__SBAddress);
}
arg2 = *argp2;
arg3 = (uint32_t)lua_tointeger(L, 3);
result = (arg1)->ReadInstructions(arg2,arg3);
{
lldb::SBInstructionList * resultptr = new lldb::SBInstructionList((const lldb::SBInstructionList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_ReadInstructions__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBAddress arg2 ;
uint32_t arg3 ;
char *arg4 = (char *) 0 ;
lldb::SBAddress *argp2 ;
lldb::SBInstructionList result;
SWIG_check_num_args("lldb::SBTarget::ReadInstructions",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ReadInstructions",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::ReadInstructions",2,"lldb::SBAddress");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::ReadInstructions",3,"uint32_t");
if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBTarget::ReadInstructions",4,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_ReadInstructions",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBTarget_ReadInstructions",2,SWIGTYPE_p_lldb__SBAddress);
}
arg2 = *argp2;
arg3 = (uint32_t)lua_tointeger(L, 3);
arg4 = (char *)lua_tostring(L, 4);
result = (arg1)->ReadInstructions(arg2,arg3,(char const *)arg4);
{
lldb::SBInstructionList * resultptr = new lldb::SBInstructionList((const lldb::SBInstructionList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_ReadInstructions(lua_State* L) {
int argc;
int argv[5]={
1,2,3,4,5
};
argc = lua_gettop(L);
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBTarget_ReadInstructions__SWIG_0(L);
}
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[3]);
}
if (_v) {
return _wrap_SBTarget_ReadInstructions__SWIG_1(L);
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTarget_ReadInstructions'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTarget::ReadInstructions(lldb::SBAddress,uint32_t)\n"
" lldb::SBTarget::ReadInstructions(lldb::SBAddress,uint32_t,char const *)\n");
lua_error(L);return 0;
}
static int _wrap_SBTarget_GetInstructions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBAddress arg2 ;
void *arg3 = (void *) 0 ;
size_t arg4 ;
lldb::SBAddress *argp2 ;
lldb::SBInstructionList result;
SWIG_check_num_args("lldb::SBTarget::GetInstructions",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetInstructions",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::GetInstructions",2,"lldb::SBAddress");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetInstructions",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBTarget_GetInstructions",2,SWIGTYPE_p_lldb__SBAddress);
}
arg2 = *argp2;
{
arg3 = (void *)luaL_checklstring(L, 3, &arg4);
}
result = (arg1)->GetInstructions(arg2,(void const *)arg3,arg4);
{
lldb::SBInstructionList * resultptr = new lldb::SBInstructionList((const lldb::SBInstructionList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetInstructionsWithFlavor(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBAddress arg2 ;
char *arg3 = (char *) 0 ;
void *arg4 = (void *) 0 ;
size_t arg5 ;
lldb::SBAddress *argp2 ;
lldb::SBInstructionList result;
SWIG_check_num_args("lldb::SBTarget::GetInstructionsWithFlavor",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetInstructionsWithFlavor",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::GetInstructionsWithFlavor",2,"lldb::SBAddress");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTarget::GetInstructionsWithFlavor",3,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetInstructionsWithFlavor",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBTarget_GetInstructionsWithFlavor",2,SWIGTYPE_p_lldb__SBAddress);
}
arg2 = *argp2;
arg3 = (char *)lua_tostring(L, 3);
{
arg4 = (void *)luaL_checklstring(L, 4, &arg5);
}
result = (arg1)->GetInstructionsWithFlavor(arg2,(char const *)arg3,(void const *)arg4,arg5);
{
lldb::SBInstructionList * resultptr = new lldb::SBInstructionList((const lldb::SBInstructionList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_FindSymbols__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SymbolType arg3 ;
lldb::SBSymbolContextList result;
SWIG_check_num_args("lldb::SBTarget::FindSymbols",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindSymbols",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindSymbols",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::FindSymbols",3,"lldb::SymbolType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_FindSymbols",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (lldb::SymbolType)lua_tointeger(L, 3);
result = (arg1)->FindSymbols((char const *)arg2,arg3);
{
lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList((const lldb::SBSymbolContextList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_FindSymbols__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBSymbolContextList result;
SWIG_check_num_args("lldb::SBTarget::FindSymbols",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindSymbols",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindSymbols",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_FindSymbols",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->FindSymbols((char const *)arg2);
{
lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList((const lldb::SBSymbolContextList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_FindSymbols(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBTarget_FindSymbols__SWIG_1(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBTarget_FindSymbols__SWIG_0(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTarget_FindSymbols'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTarget::FindSymbols(char const *,lldb::SymbolType)\n"
" lldb::SBTarget::FindSymbols(char const *)\n");
lua_error(L);return 0;
}
static int _wrap_SBTarget_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBStream *arg2 = 0 ;
lldb::DescriptionLevel arg3 ;
bool result;
SWIG_check_num_args("lldb::SBTarget::GetDescription",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetDescription",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::GetDescription",2,"lldb::SBStream &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::GetDescription",3,"lldb::DescriptionLevel");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetDescription",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBTarget_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3);
result = (bool)(arg1)->GetDescription(*arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetStackRedZoneSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBTarget::GetStackRedZoneSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetStackRedZoneSize",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetStackRedZoneSize",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (lldb::addr_t)(arg1)->GetStackRedZoneSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_IsLoaded(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBModule *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBTarget::IsLoaded",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::IsLoaded",1,"lldb::SBTarget const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::IsLoaded",2,"lldb::SBModule const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_IsLoaded",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBModule,0))){
SWIG_fail_ptr("SBTarget_IsLoaded",2,SWIGTYPE_p_lldb__SBModule);
}
result = (bool)((lldb::SBTarget const *)arg1)->IsLoaded((lldb::SBModule const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetLaunchInfo(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
SwigValueWrapper< lldb::SBLaunchInfo > result;
SWIG_check_num_args("lldb::SBTarget::GetLaunchInfo",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetLaunchInfo",1,"lldb::SBTarget const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetLaunchInfo",1,SWIGTYPE_p_lldb__SBTarget);
}
result = ((lldb::SBTarget const *)arg1)->GetLaunchInfo();
{
lldb::SBLaunchInfo * resultptr = new lldb::SBLaunchInfo((const lldb::SBLaunchInfo &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBLaunchInfo,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_SetLaunchInfo(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBLaunchInfo *arg2 = 0 ;
SWIG_check_num_args("lldb::SBTarget::SetLaunchInfo",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::SetLaunchInfo",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::SetLaunchInfo",2,"lldb::SBLaunchInfo const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_SetLaunchInfo",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBLaunchInfo,0))){
SWIG_fail_ptr("SBTarget_SetLaunchInfo",2,SWIGTYPE_p_lldb__SBLaunchInfo);
}
(arg1)->SetLaunchInfo((lldb::SBLaunchInfo const &)*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_SetCollectingStats(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBTarget::SetCollectingStats",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::SetCollectingStats",1,"lldb::SBTarget *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBTarget::SetCollectingStats",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_SetCollectingStats",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetCollectingStats(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetCollectingStats(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTarget::GetCollectingStats",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetCollectingStats",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetCollectingStats",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (bool)(arg1)->GetCollectingStats();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetStatistics(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBStructuredData result;
SWIG_check_num_args("lldb::SBTarget::GetStatistics",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetStatistics",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetStatistics",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (arg1)->GetStatistics();
{
lldb::SBStructuredData * resultptr = new lldb::SBStructuredData((const lldb::SBStructuredData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBTarget *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBTarget::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::operator ==",1,"lldb::SBTarget const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::operator ==",2,"lldb::SBTarget const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget___eq",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget___eq",2,SWIGTYPE_p_lldb__SBTarget);
}
result = (bool)((lldb::SBTarget const *)arg1)->operator ==((lldb::SBTarget const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_EvaluateExpression__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBTarget::EvaluateExpression",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::EvaluateExpression",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::EvaluateExpression",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_EvaluateExpression",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->EvaluateExpression((char const *)arg2);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_EvaluateExpression__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBExpressionOptions *arg3 = 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBTarget::EvaluateExpression",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::EvaluateExpression",1,"lldb::SBTarget *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::EvaluateExpression",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::EvaluateExpression",3,"lldb::SBExpressionOptions const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_EvaluateExpression",1,SWIGTYPE_p_lldb__SBTarget);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBTarget_EvaluateExpression",3,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (arg1)->EvaluateExpression((char const *)arg2,(lldb::SBExpressionOptions const &)*arg3);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_EvaluateExpression(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBTarget_EvaluateExpression__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTarget_EvaluateExpression__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTarget_EvaluateExpression'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTarget::EvaluateExpression(char const *)\n"
" lldb::SBTarget::EvaluateExpression(char const *,lldb::SBExpressionOptions const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTarget___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBTarget::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::__str__",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget___tostring",1,SWIGTYPE_p_lldb__SBTarget);
}
result = lldb_SBTarget___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_GetTrace(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBTrace result;
SWIG_check_num_args("lldb::SBTarget::GetTrace",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetTrace",1,"lldb::SBTarget *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_GetTrace",1,SWIGTYPE_p_lldb__SBTarget);
}
result = (arg1)->GetTrace();
{
lldb::SBTrace * resultptr = new lldb::SBTrace((const lldb::SBTrace &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTrace,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTarget_CreateTrace(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ;
lldb::SBError *arg2 = 0 ;
lldb::SBTrace result;
SWIG_check_num_args("lldb::SBTarget::CreateTrace",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::CreateTrace",1,"lldb::SBTarget *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::CreateTrace",2,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBTarget_CreateTrace",1,SWIGTYPE_p_lldb__SBTarget);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBTarget_CreateTrace",2,SWIGTYPE_p_lldb__SBError);
}
result = (arg1)->CreateTrace(*arg2);
{
lldb::SBTrace * resultptr = new lldb::SBTrace((const lldb::SBTrace &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTrace,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBTarget(void *obj) {
lldb::SBTarget *arg1 = (lldb::SBTarget *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBTarget(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBTarget);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBTarget_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBTarget_methods[]= {
{ "IsValid", _wrap_SBTarget_IsValid},
{ "GetProcess", _wrap_SBTarget_GetProcess},
{ "GetPlatform", _wrap_SBTarget_GetPlatform},
{ "Install", _wrap_SBTarget_Install},
{ "LaunchSimple", _wrap_SBTarget_LaunchSimple},
{ "Launch", _wrap_SBTarget_Launch},
{ "LoadCore", _wrap_SBTarget_LoadCore},
{ "Attach", _wrap_SBTarget_Attach},
{ "AttachToProcessWithID", _wrap_SBTarget_AttachToProcessWithID},
{ "AttachToProcessWithName", _wrap_SBTarget_AttachToProcessWithName},
{ "ConnectRemote", _wrap_SBTarget_ConnectRemote},
{ "GetExecutable", _wrap_SBTarget_GetExecutable},
{ "AppendImageSearchPath", _wrap_SBTarget_AppendImageSearchPath},
{ "AddModule", _wrap_SBTarget_AddModule},
{ "GetNumModules", _wrap_SBTarget_GetNumModules},
{ "GetModuleAtIndex", _wrap_SBTarget_GetModuleAtIndex},
{ "RemoveModule", _wrap_SBTarget_RemoveModule},
{ "GetDebugger", _wrap_SBTarget_GetDebugger},
{ "FindModule", _wrap_SBTarget_FindModule},
{ "FindCompileUnits", _wrap_SBTarget_FindCompileUnits},
{ "GetByteOrder", _wrap_SBTarget_GetByteOrder},
{ "GetAddressByteSize", _wrap_SBTarget_GetAddressByteSize},
{ "GetTriple", _wrap_SBTarget_GetTriple},
{ "GetDataByteSize", _wrap_SBTarget_GetDataByteSize},
{ "GetCodeByteSize", _wrap_SBTarget_GetCodeByteSize},
{ "GetMaximumNumberOfChildrenToDisplay", _wrap_SBTarget_GetMaximumNumberOfChildrenToDisplay},
{ "SetSectionLoadAddress", _wrap_SBTarget_SetSectionLoadAddress},
{ "ClearSectionLoadAddress", _wrap_SBTarget_ClearSectionLoadAddress},
{ "SetModuleLoadAddress", _wrap_SBTarget_SetModuleLoadAddress},
{ "ClearModuleLoadAddress", _wrap_SBTarget_ClearModuleLoadAddress},
{ "FindFunctions", _wrap_SBTarget_FindFunctions},
{ "FindFirstType", _wrap_SBTarget_FindFirstType},
{ "FindTypes", _wrap_SBTarget_FindTypes},
{ "GetBasicType", _wrap_SBTarget_GetBasicType},
{ "GetSourceManager", _wrap_SBTarget_GetSourceManager},
{ "FindFirstGlobalVariable", _wrap_SBTarget_FindFirstGlobalVariable},
{ "FindGlobalVariables", _wrap_SBTarget_FindGlobalVariables},
{ "FindGlobalFunctions", _wrap_SBTarget_FindGlobalFunctions},
{ "Clear", _wrap_SBTarget_Clear},
{ "ResolveFileAddress", _wrap_SBTarget_ResolveFileAddress},
{ "ResolveLoadAddress", _wrap_SBTarget_ResolveLoadAddress},
{ "ResolvePastLoadAddress", _wrap_SBTarget_ResolvePastLoadAddress},
{ "ResolveSymbolContextForAddress", _wrap_SBTarget_ResolveSymbolContextForAddress},
{ "ReadMemory", _wrap_SBTarget_ReadMemory},
{ "BreakpointCreateByLocation", _wrap_SBTarget_BreakpointCreateByLocation},
{ "BreakpointCreateByName", _wrap_SBTarget_BreakpointCreateByName},
{ "BreakpointCreateByNames", _wrap_SBTarget_BreakpointCreateByNames},
{ "BreakpointCreateByRegex", _wrap_SBTarget_BreakpointCreateByRegex},
{ "BreakpointCreateBySourceRegex", _wrap_SBTarget_BreakpointCreateBySourceRegex},
{ "BreakpointCreateForException", _wrap_SBTarget_BreakpointCreateForException},
{ "BreakpointCreateByAddress", _wrap_SBTarget_BreakpointCreateByAddress},
{ "GetEnvironment", _wrap_SBTarget_GetEnvironment},
{ "BreakpointCreateBySBAddress", _wrap_SBTarget_BreakpointCreateBySBAddress},
{ "BreakpointCreateFromScript", _wrap_SBTarget_BreakpointCreateFromScript},
{ "GetNumBreakpoints", _wrap_SBTarget_GetNumBreakpoints},
{ "GetBreakpointAtIndex", _wrap_SBTarget_GetBreakpointAtIndex},
{ "BreakpointDelete", _wrap_SBTarget_BreakpointDelete},
{ "FindBreakpointByID", _wrap_SBTarget_FindBreakpointByID},
{ "FindBreakpointsByName", _wrap_SBTarget_FindBreakpointsByName},
{ "DeleteBreakpointName", _wrap_SBTarget_DeleteBreakpointName},
{ "GetBreakpointNames", _wrap_SBTarget_GetBreakpointNames},
{ "EnableAllBreakpoints", _wrap_SBTarget_EnableAllBreakpoints},
{ "DisableAllBreakpoints", _wrap_SBTarget_DisableAllBreakpoints},
{ "DeleteAllBreakpoints", _wrap_SBTarget_DeleteAllBreakpoints},
{ "BreakpointsCreateFromFile", _wrap_SBTarget_BreakpointsCreateFromFile},
{ "BreakpointsWriteToFile", _wrap_SBTarget_BreakpointsWriteToFile},
{ "GetNumWatchpoints", _wrap_SBTarget_GetNumWatchpoints},
{ "GetWatchpointAtIndex", _wrap_SBTarget_GetWatchpointAtIndex},
{ "DeleteWatchpoint", _wrap_SBTarget_DeleteWatchpoint},
{ "FindWatchpointByID", _wrap_SBTarget_FindWatchpointByID},
{ "EnableAllWatchpoints", _wrap_SBTarget_EnableAllWatchpoints},
{ "DisableAllWatchpoints", _wrap_SBTarget_DisableAllWatchpoints},
{ "DeleteAllWatchpoints", _wrap_SBTarget_DeleteAllWatchpoints},
{ "WatchAddress", _wrap_SBTarget_WatchAddress},
{ "GetBroadcaster", _wrap_SBTarget_GetBroadcaster},
{ "CreateValueFromAddress", _wrap_SBTarget_CreateValueFromAddress},
{ "CreateValueFromData", _wrap_SBTarget_CreateValueFromData},
{ "CreateValueFromExpression", _wrap_SBTarget_CreateValueFromExpression},
{ "ReadInstructions", _wrap_SBTarget_ReadInstructions},
{ "GetInstructions", _wrap_SBTarget_GetInstructions},
{ "GetInstructionsWithFlavor", _wrap_SBTarget_GetInstructionsWithFlavor},
{ "FindSymbols", _wrap_SBTarget_FindSymbols},
{ "GetDescription", _wrap_SBTarget_GetDescription},
{ "GetStackRedZoneSize", _wrap_SBTarget_GetStackRedZoneSize},
{ "IsLoaded", _wrap_SBTarget_IsLoaded},
{ "GetLaunchInfo", _wrap_SBTarget_GetLaunchInfo},
{ "SetLaunchInfo", _wrap_SBTarget_SetLaunchInfo},
{ "SetCollectingStats", _wrap_SBTarget_SetCollectingStats},
{ "GetCollectingStats", _wrap_SBTarget_GetCollectingStats},
{ "GetStatistics", _wrap_SBTarget_GetStatistics},
{ "__eq", _wrap_SBTarget___eq},
{ "EvaluateExpression", _wrap_SBTarget_EvaluateExpression},
{ "__tostring", _wrap_SBTarget___tostring},
{ "GetTrace", _wrap_SBTarget_GetTrace},
{ "CreateTrace", _wrap_SBTarget_CreateTrace},
{0,0}
};
static swig_lua_method swig_SBTarget_meta[] = {
{ "__eq", _wrap_SBTarget___eq},
{ "__tostring", _wrap_SBTarget___tostring},
{0,0}
};
static swig_lua_attribute swig_SBTarget_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBTarget_Sf_SwigStatic_constants[]= {
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitBreakpointChanged", lldb::SBTarget::eBroadcastBitBreakpointChanged)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitModulesLoaded", lldb::SBTarget::eBroadcastBitModulesLoaded)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitModulesUnloaded", lldb::SBTarget::eBroadcastBitModulesUnloaded)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitWatchpointChanged", lldb::SBTarget::eBroadcastBitWatchpointChanged)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitSymbolsLoaded", lldb::SBTarget::eBroadcastBitSymbolsLoaded)},
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBTarget_Sf_SwigStatic_methods[]= {
{ "GetBroadcasterClassName", _wrap_SBTarget_GetBroadcasterClassName},
{ "EventIsTargetEvent", _wrap_SBTarget_EventIsTargetEvent},
{ "GetTargetFromEvent", _wrap_SBTarget_GetTargetFromEvent},
{ "GetNumModulesFromEvent", _wrap_SBTarget_GetNumModulesFromEvent},
{ "GetModuleAtIndexFromEvent", _wrap_SBTarget_GetModuleAtIndexFromEvent},
{0,0}
};
static swig_lua_class* swig_SBTarget_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBTarget_Sf_SwigStatic = {
"SBTarget",
swig_SBTarget_Sf_SwigStatic_methods,
swig_SBTarget_Sf_SwigStatic_attributes,
swig_SBTarget_Sf_SwigStatic_constants,
swig_SBTarget_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBTarget_bases[] = {0};
static const char *swig_SBTarget_base_names[] = {0};
static swig_lua_class _wrap_class_SBTarget = { "SBTarget", "SBTarget", &SWIGTYPE_p_lldb__SBTarget,_proxy__wrap_new_SBTarget, swig_delete_SBTarget, swig_SBTarget_methods, swig_SBTarget_attributes, &swig_SBTarget_Sf_SwigStatic, swig_SBTarget_meta, swig_SBTarget_bases, swig_SBTarget_base_names };
static int _wrap_new_SBThread__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *result = 0 ;
SWIG_check_num_args("lldb::SBThread::SBThread",0,0)
result = (lldb::SBThread *)new lldb::SBThread();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBThread__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = 0 ;
lldb::SBThread *result = 0 ;
SWIG_check_num_args("lldb::SBThread::SBThread",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBThread::SBThread",1,"lldb::SBThread const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("new_SBThread",1,SWIGTYPE_p_lldb__SBThread);
}
result = (lldb::SBThread *)new lldb::SBThread((lldb::SBThread const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBThread(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBThread__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBThread__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBThread'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBThread::SBThread()\n"
" lldb::SBThread::SBThread(lldb::SBThread const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBThread_GetBroadcasterClassName(lua_State* L) {
int SWIG_arg = 0;
char *result = 0 ;
SWIG_check_num_args("lldb::SBThread::GetBroadcasterClassName",0,0)
result = (char *)lldb::SBThread::GetBroadcasterClassName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_EventIsThreadEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBThread::EventIsThreadEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBThread::EventIsThreadEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBThread_EventIsThreadEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)lldb::SBThread::EventIsThreadEvent((lldb::SBEvent const &)*arg1);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetStackFrameFromEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
lldb::SBFrame result;
SWIG_check_num_args("lldb::SBThread::GetStackFrameFromEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBThread::GetStackFrameFromEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBThread_GetStackFrameFromEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = lldb::SBThread::GetStackFrameFromEvent((lldb::SBEvent const &)*arg1);
{
lldb::SBFrame * resultptr = new lldb::SBFrame((const lldb::SBFrame &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFrame,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetThreadFromEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
lldb::SBThread result;
SWIG_check_num_args("lldb::SBThread::GetThreadFromEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBThread::GetThreadFromEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBThread_GetThreadFromEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = lldb::SBThread::GetThreadFromEvent((lldb::SBEvent const &)*arg1);
{
lldb::SBThread * resultptr = new lldb::SBThread((const lldb::SBThread &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBThread::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::IsValid",1,"lldb::SBThread const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_IsValid",1,SWIGTYPE_p_lldb__SBThread);
}
result = (bool)((lldb::SBThread const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
SWIG_check_num_args("lldb::SBThread::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::Clear",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_Clear",1,SWIGTYPE_p_lldb__SBThread);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetStopReason(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::StopReason result;
SWIG_check_num_args("lldb::SBThread::GetStopReason",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetStopReason",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetStopReason",1,SWIGTYPE_p_lldb__SBThread);
}
result = (lldb::StopReason)(arg1)->GetStopReason();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetStopReasonDataCount(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBThread::GetStopReasonDataCount",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetStopReasonDataCount",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetStopReasonDataCount",1,SWIGTYPE_p_lldb__SBThread);
}
result = (arg1)->GetStopReasonDataCount();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetStopReasonDataAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
uint32_t arg2 ;
uint64_t result;
SWIG_check_num_args("lldb::SBThread::GetStopReasonDataAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetStopReasonDataAtIndex",1,"lldb::SBThread *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThread::GetStopReasonDataAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetStopReasonDataAtIndex",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (uint64_t)(arg1)->GetStopReasonDataAtIndex(arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetStopReasonExtendedInfoAsJSON(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBThread::GetStopReasonExtendedInfoAsJSON",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetStopReasonExtendedInfoAsJSON",1,"lldb::SBThread *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::GetStopReasonExtendedInfoAsJSON",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetStopReasonExtendedInfoAsJSON",1,SWIGTYPE_p_lldb__SBThread);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBThread_GetStopReasonExtendedInfoAsJSON",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetStopReasonExtendedInfoAsJSON(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetStopReasonExtendedBacktraces(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::InstrumentationRuntimeType arg2 ;
lldb::SBThreadCollection result;
SWIG_check_num_args("lldb::SBThread::GetStopReasonExtendedBacktraces",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetStopReasonExtendedBacktraces",1,"lldb::SBThread *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThread::GetStopReasonExtendedBacktraces",2,"lldb::InstrumentationRuntimeType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetStopReasonExtendedBacktraces",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (lldb::InstrumentationRuntimeType)lua_tointeger(L, 2);
result = (arg1)->GetStopReasonExtendedBacktraces(arg2);
{
lldb::SBThreadCollection * resultptr = new lldb::SBThreadCollection((const lldb::SBThreadCollection &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadCollection,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetStopDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
char *arg2 = (char *) 0 ;
size_t arg3 ;
size_t result;
SWIG_check_num_args("lldb::SBThread::GetStopDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetStopDescription",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetStopDescription",1,SWIGTYPE_p_lldb__SBThread);
}
{
arg3 = luaL_checkinteger(L, 2);
if (arg3 <= 0) {
return luaL_error(L, "Positive integer expected");
}
arg2 = (char *)malloc(arg3);
}
result = (arg1)->GetStopDescription(arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
{
lua_pop(L, 1); // Blow away the previous result
lua_pushlstring(L, (const char *)arg2, result);
free(arg2);
// SWIG_arg was already incremented
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetStopReturnValue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBThread::GetStopReturnValue",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetStopReturnValue",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetStopReturnValue",1,SWIGTYPE_p_lldb__SBThread);
}
result = (arg1)->GetStopReturnValue();
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetThreadID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::tid_t result;
SWIG_check_num_args("lldb::SBThread::GetThreadID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetThreadID",1,"lldb::SBThread const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetThreadID",1,SWIGTYPE_p_lldb__SBThread);
}
result = (lldb::tid_t)((lldb::SBThread const *)arg1)->GetThreadID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetIndexID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBThread::GetIndexID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetIndexID",1,"lldb::SBThread const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetIndexID",1,SWIGTYPE_p_lldb__SBThread);
}
result = (uint32_t)((lldb::SBThread const *)arg1)->GetIndexID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBThread::GetName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetName",1,"lldb::SBThread const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetName",1,SWIGTYPE_p_lldb__SBThread);
}
result = (char *)((lldb::SBThread const *)arg1)->GetName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetQueueName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBThread::GetQueueName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetQueueName",1,"lldb::SBThread const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetQueueName",1,SWIGTYPE_p_lldb__SBThread);
}
result = (char *)((lldb::SBThread const *)arg1)->GetQueueName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetQueueID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::queue_id_t result;
SWIG_check_num_args("lldb::SBThread::GetQueueID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetQueueID",1,"lldb::SBThread const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetQueueID",1,SWIGTYPE_p_lldb__SBThread);
}
result = (lldb::queue_id_t)((lldb::SBThread const *)arg1)->GetQueueID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetInfoItemByPathAsString(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBStream *arg3 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBThread::GetInfoItemByPathAsString",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetInfoItemByPathAsString",1,"lldb::SBThread *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThread::GetInfoItemByPathAsString",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThread::GetInfoItemByPathAsString",3,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetInfoItemByPathAsString",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBThread_GetInfoItemByPathAsString",3,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetInfoItemByPathAsString((char const *)arg2,*arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetQueue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBQueue result;
SWIG_check_num_args("lldb::SBThread::GetQueue",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetQueue",1,"lldb::SBThread const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetQueue",1,SWIGTYPE_p_lldb__SBThread);
}
result = ((lldb::SBThread const *)arg1)->GetQueue();
{
lldb::SBQueue * resultptr = new lldb::SBQueue((const lldb::SBQueue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBQueue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepOver__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::RunMode arg2 ;
SWIG_check_num_args("lldb::SBThread::StepOver",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepOver",1,"lldb::SBThread *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThread::StepOver",2,"lldb::RunMode");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepOver",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (lldb::RunMode)lua_tointeger(L, 2);
(arg1)->StepOver(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepOver__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
SWIG_check_num_args("lldb::SBThread::StepOver",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepOver",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepOver",1,SWIGTYPE_p_lldb__SBThread);
}
(arg1)->StepOver();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepOver__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::RunMode arg2 ;
lldb::SBError *arg3 = 0 ;
SWIG_check_num_args("lldb::SBThread::StepOver",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepOver",1,"lldb::SBThread *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThread::StepOver",2,"lldb::RunMode");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThread::StepOver",3,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepOver",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (lldb::RunMode)lua_tointeger(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBThread_StepOver",3,SWIGTYPE_p_lldb__SBError);
}
(arg1)->StepOver(arg2,*arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepOver(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThread_StepOver__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBThread_StepOver__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThread_StepOver__SWIG_2(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBThread_StepOver'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBThread::StepOver(lldb::RunMode)\n"
" lldb::SBThread::StepOver()\n"
" lldb::SBThread::StepOver(lldb::RunMode,lldb::SBError &)\n");
lua_error(L);return 0;
}
static int _wrap_SBThread_StepInto__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::RunMode arg2 ;
SWIG_check_num_args("lldb::SBThread::StepInto",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepInto",1,"lldb::SBThread *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThread::StepInto",2,"lldb::RunMode");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepInto",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (lldb::RunMode)lua_tointeger(L, 2);
(arg1)->StepInto(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepInto__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
SWIG_check_num_args("lldb::SBThread::StepInto",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepInto",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepInto",1,SWIGTYPE_p_lldb__SBThread);
}
(arg1)->StepInto();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepInto__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
char *arg2 = (char *) 0 ;
lldb::RunMode arg3 ;
SWIG_check_num_args("lldb::SBThread::StepInto",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepInto",1,"lldb::SBThread *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThread::StepInto",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBThread::StepInto",3,"lldb::RunMode");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepInto",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (lldb::RunMode)lua_tointeger(L, 3);
(arg1)->StepInto((char const *)arg2,arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepInto__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBThread::StepInto",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepInto",1,"lldb::SBThread *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThread::StepInto",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepInto",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->StepInto((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepInto__SWIG_4(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
char *arg2 = (char *) 0 ;
uint32_t arg3 ;
lldb::SBError *arg4 = 0 ;
lldb::RunMode arg5 ;
SWIG_check_num_args("lldb::SBThread::StepInto",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepInto",1,"lldb::SBThread *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThread::StepInto",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBThread::StepInto",3,"uint32_t");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBThread::StepInto",4,"lldb::SBError &");
if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBThread::StepInto",5,"lldb::RunMode");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepInto",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBThread_StepInto",4,SWIGTYPE_p_lldb__SBError);
}
arg5 = (lldb::RunMode)lua_tointeger(L, 5);
(arg1)->StepInto((char const *)arg2,arg3,*arg4,arg5);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepInto__SWIG_5(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
char *arg2 = (char *) 0 ;
uint32_t arg3 ;
lldb::SBError *arg4 = 0 ;
SWIG_check_num_args("lldb::SBThread::StepInto",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepInto",1,"lldb::SBThread *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThread::StepInto",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBThread::StepInto",3,"uint32_t");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBThread::StepInto",4,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepInto",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBThread_StepInto",4,SWIGTYPE_p_lldb__SBError);
}
(arg1)->StepInto((char const *)arg2,arg3,*arg4);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepInto(lua_State* L) {
int argc;
int argv[6]={
1,2,3,4,5,6
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThread_StepInto__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBThread_StepInto__SWIG_0(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBThread_StepInto__SWIG_3(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBThread_StepInto__SWIG_2(L);
}
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThread_StepInto__SWIG_5(L);
}
}
}
}
}
if (argc == 5) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[4]);
}
if (_v) {
return _wrap_SBThread_StepInto__SWIG_4(L);
}
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBThread_StepInto'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBThread::StepInto(lldb::RunMode)\n"
" lldb::SBThread::StepInto()\n"
" lldb::SBThread::StepInto(char const *,lldb::RunMode)\n"
" lldb::SBThread::StepInto(char const *)\n"
" lldb::SBThread::StepInto(char const *,uint32_t,lldb::SBError &,lldb::RunMode)\n"
" lldb::SBThread::StepInto(char const *,uint32_t,lldb::SBError &)\n");
lua_error(L);return 0;
}
static int _wrap_SBThread_StepOut__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
SWIG_check_num_args("lldb::SBThread::StepOut",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepOut",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepOut",1,SWIGTYPE_p_lldb__SBThread);
}
(arg1)->StepOut();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepOut__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBError *arg2 = 0 ;
SWIG_check_num_args("lldb::SBThread::StepOut",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepOut",1,"lldb::SBThread *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::StepOut",2,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepOut",1,SWIGTYPE_p_lldb__SBThread);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBThread_StepOut",2,SWIGTYPE_p_lldb__SBError);
}
(arg1)->StepOut(*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepOut(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThread_StepOut__SWIG_0(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThread_StepOut__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBThread_StepOut'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBThread::StepOut()\n"
" lldb::SBThread::StepOut(lldb::SBError &)\n");
lua_error(L);return 0;
}
static int _wrap_SBThread_StepOutOfFrame__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBFrame *arg2 = 0 ;
SWIG_check_num_args("lldb::SBThread::StepOutOfFrame",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepOutOfFrame",1,"lldb::SBThread *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::StepOutOfFrame",2,"lldb::SBFrame &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepOutOfFrame",1,SWIGTYPE_p_lldb__SBThread);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBThread_StepOutOfFrame",2,SWIGTYPE_p_lldb__SBFrame);
}
(arg1)->StepOutOfFrame(*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepOutOfFrame__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBFrame *arg2 = 0 ;
lldb::SBError *arg3 = 0 ;
SWIG_check_num_args("lldb::SBThread::StepOutOfFrame",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepOutOfFrame",1,"lldb::SBThread *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::StepOutOfFrame",2,"lldb::SBFrame &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThread::StepOutOfFrame",3,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepOutOfFrame",1,SWIGTYPE_p_lldb__SBThread);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBThread_StepOutOfFrame",2,SWIGTYPE_p_lldb__SBFrame);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBThread_StepOutOfFrame",3,SWIGTYPE_p_lldb__SBError);
}
(arg1)->StepOutOfFrame(*arg2,*arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepOutOfFrame(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThread_StepOutOfFrame__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThread_StepOutOfFrame__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBThread_StepOutOfFrame'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBThread::StepOutOfFrame(lldb::SBFrame &)\n"
" lldb::SBThread::StepOutOfFrame(lldb::SBFrame &,lldb::SBError &)\n");
lua_error(L);return 0;
}
static int _wrap_SBThread_StepInstruction__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBThread::StepInstruction",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepInstruction",1,"lldb::SBThread *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBThread::StepInstruction",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepInstruction",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->StepInstruction(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepInstruction__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
bool arg2 ;
lldb::SBError *arg3 = 0 ;
SWIG_check_num_args("lldb::SBThread::StepInstruction",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepInstruction",1,"lldb::SBThread *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBThread::StepInstruction",2,"bool");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThread::StepInstruction",3,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepInstruction",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (lua_toboolean(L, 2)!=0);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBThread_StepInstruction",3,SWIGTYPE_p_lldb__SBError);
}
(arg1)->StepInstruction(arg2,*arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepInstruction(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_SBThread_StepInstruction__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThread_StepInstruction__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBThread_StepInstruction'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBThread::StepInstruction(bool)\n"
" lldb::SBThread::StepInstruction(bool,lldb::SBError &)\n");
lua_error(L);return 0;
}
static int _wrap_SBThread_StepOverUntil(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBFrame *arg2 = 0 ;
lldb::SBFileSpec *arg3 = 0 ;
uint32_t arg4 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBThread::StepOverUntil",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepOverUntil",1,"lldb::SBThread *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::StepOverUntil",2,"lldb::SBFrame &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThread::StepOverUntil",3,"lldb::SBFileSpec &");
if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBThread::StepOverUntil",4,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepOverUntil",1,SWIGTYPE_p_lldb__SBThread);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBThread_StepOverUntil",2,SWIGTYPE_p_lldb__SBFrame);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBThread_StepOverUntil",3,SWIGTYPE_p_lldb__SBFileSpec);
}
arg4 = (uint32_t)lua_tointeger(L, 4);
result = (arg1)->StepOverUntil(*arg2,*arg3,arg4);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBThread::StepUsingScriptedThreadPlan",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepUsingScriptedThreadPlan",1,"lldb::SBThread *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThread::StepUsingScriptedThreadPlan",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepUsingScriptedThreadPlan",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->StepUsingScriptedThreadPlan((char const *)arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
char *arg2 = (char *) 0 ;
bool arg3 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBThread::StepUsingScriptedThreadPlan",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepUsingScriptedThreadPlan",1,"lldb::SBThread *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThread::StepUsingScriptedThreadPlan",2,"char const *");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBThread::StepUsingScriptedThreadPlan",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepUsingScriptedThreadPlan",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (lua_toboolean(L, 3)!=0);
result = (arg1)->StepUsingScriptedThreadPlan((char const *)arg2,arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBStructuredData *arg3 = 0 ;
bool arg4 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBThread::StepUsingScriptedThreadPlan",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepUsingScriptedThreadPlan",1,"lldb::SBThread *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThread::StepUsingScriptedThreadPlan",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThread::StepUsingScriptedThreadPlan",3,"lldb::SBStructuredData &");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBThread::StepUsingScriptedThreadPlan",4,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_StepUsingScriptedThreadPlan",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBThread_StepUsingScriptedThreadPlan",3,SWIGTYPE_p_lldb__SBStructuredData);
}
arg4 = (lua_toboolean(L, 4)!=0);
result = (arg1)->StepUsingScriptedThreadPlan((char const *)arg2,*arg3,arg4);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_StepUsingScriptedThreadPlan(lua_State* L) {
int argc;
int argv[5]={
1,2,3,4,5
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[2]);
}
if (_v) {
return _wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_1(L);
}
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[3]);
}
if (_v) {
return _wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_2(L);
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBThread_StepUsingScriptedThreadPlan'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBThread::StepUsingScriptedThreadPlan(char const *)\n"
" lldb::SBThread::StepUsingScriptedThreadPlan(char const *,bool)\n"
" lldb::SBThread::StepUsingScriptedThreadPlan(char const *,lldb::SBStructuredData &,bool)\n");
lua_error(L);return 0;
}
static int _wrap_SBThread_JumpToLine(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBFileSpec *arg2 = 0 ;
uint32_t arg3 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBThread::JumpToLine",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::JumpToLine",1,"lldb::SBThread *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::JumpToLine",2,"lldb::SBFileSpec &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBThread::JumpToLine",3,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_JumpToLine",1,SWIGTYPE_p_lldb__SBThread);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){
SWIG_fail_ptr("SBThread_JumpToLine",2,SWIGTYPE_p_lldb__SBFileSpec);
}
arg3 = (uint32_t)lua_tointeger(L, 3);
result = (arg1)->JumpToLine(*arg2,arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_RunToAddress__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::addr_t arg2 ;
SWIG_check_num_args("lldb::SBThread::RunToAddress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::RunToAddress",1,"lldb::SBThread *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThread::RunToAddress",2,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_RunToAddress",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
(arg1)->RunToAddress(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_RunToAddress__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::addr_t arg2 ;
lldb::SBError *arg3 = 0 ;
SWIG_check_num_args("lldb::SBThread::RunToAddress",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::RunToAddress",1,"lldb::SBThread *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThread::RunToAddress",2,"lldb::addr_t");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThread::RunToAddress",3,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_RunToAddress",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (lldb::addr_t)lua_tointeger(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBThread_RunToAddress",3,SWIGTYPE_p_lldb__SBError);
}
(arg1)->RunToAddress(arg2,*arg3);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_RunToAddress(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBThread_RunToAddress__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThread_RunToAddress__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBThread_RunToAddress'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBThread::RunToAddress(lldb::addr_t)\n"
" lldb::SBThread::RunToAddress(lldb::addr_t,lldb::SBError &)\n");
lua_error(L);return 0;
}
static int _wrap_SBThread_ReturnFromFrame(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBFrame *arg2 = 0 ;
lldb::SBValue *arg3 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBThread::ReturnFromFrame",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::ReturnFromFrame",1,"lldb::SBThread *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::ReturnFromFrame",2,"lldb::SBFrame &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThread::ReturnFromFrame",3,"lldb::SBValue &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_ReturnFromFrame",1,SWIGTYPE_p_lldb__SBThread);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFrame,0))){
SWIG_fail_ptr("SBThread_ReturnFromFrame",2,SWIGTYPE_p_lldb__SBFrame);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBThread_ReturnFromFrame",3,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->ReturnFromFrame(*arg2,*arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_UnwindInnermostExpression(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBThread::UnwindInnermostExpression",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::UnwindInnermostExpression",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_UnwindInnermostExpression",1,SWIGTYPE_p_lldb__SBThread);
}
result = (arg1)->UnwindInnermostExpression();
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_Suspend__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBThread::Suspend",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::Suspend",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_Suspend",1,SWIGTYPE_p_lldb__SBThread);
}
result = (bool)(arg1)->Suspend();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_Suspend__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBError *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBThread::Suspend",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::Suspend",1,"lldb::SBThread *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::Suspend",2,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_Suspend",1,SWIGTYPE_p_lldb__SBThread);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBThread_Suspend",2,SWIGTYPE_p_lldb__SBError);
}
result = (bool)(arg1)->Suspend(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_Suspend(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThread_Suspend__SWIG_0(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThread_Suspend__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBThread_Suspend'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBThread::Suspend()\n"
" lldb::SBThread::Suspend(lldb::SBError &)\n");
lua_error(L);return 0;
}
static int _wrap_SBThread_Resume__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBThread::Resume",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::Resume",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_Resume",1,SWIGTYPE_p_lldb__SBThread);
}
result = (bool)(arg1)->Resume();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_Resume__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBError *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBThread::Resume",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::Resume",1,"lldb::SBThread *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::Resume",2,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_Resume",1,SWIGTYPE_p_lldb__SBThread);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBThread_Resume",2,SWIGTYPE_p_lldb__SBError);
}
result = (bool)(arg1)->Resume(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_Resume(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThread_Resume__SWIG_0(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThread_Resume__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBThread_Resume'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBThread::Resume()\n"
" lldb::SBThread::Resume(lldb::SBError &)\n");
lua_error(L);return 0;
}
static int _wrap_SBThread_IsSuspended(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBThread::IsSuspended",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::IsSuspended",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_IsSuspended",1,SWIGTYPE_p_lldb__SBThread);
}
result = (bool)(arg1)->IsSuspended();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_IsStopped(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBThread::IsStopped",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::IsStopped",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_IsStopped",1,SWIGTYPE_p_lldb__SBThread);
}
result = (bool)(arg1)->IsStopped();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetNumFrames(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBThread::GetNumFrames",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetNumFrames",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetNumFrames",1,SWIGTYPE_p_lldb__SBThread);
}
result = (uint32_t)(arg1)->GetNumFrames();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetFrameAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
uint32_t arg2 ;
lldb::SBFrame result;
SWIG_check_num_args("lldb::SBThread::GetFrameAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetFrameAtIndex",1,"lldb::SBThread *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThread::GetFrameAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetFrameAtIndex",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetFrameAtIndex(arg2);
{
lldb::SBFrame * resultptr = new lldb::SBFrame((const lldb::SBFrame &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFrame,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetSelectedFrame(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBFrame result;
SWIG_check_num_args("lldb::SBThread::GetSelectedFrame",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetSelectedFrame",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetSelectedFrame",1,SWIGTYPE_p_lldb__SBThread);
}
result = (arg1)->GetSelectedFrame();
{
lldb::SBFrame * resultptr = new lldb::SBFrame((const lldb::SBFrame &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFrame,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_SetSelectedFrame(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
uint32_t arg2 ;
lldb::SBFrame result;
SWIG_check_num_args("lldb::SBThread::SetSelectedFrame",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::SetSelectedFrame",1,"lldb::SBThread *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThread::SetSelectedFrame",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_SetSelectedFrame",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->SetSelectedFrame(arg2);
{
lldb::SBFrame * resultptr = new lldb::SBFrame((const lldb::SBFrame &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFrame,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetProcess(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBProcess result;
SWIG_check_num_args("lldb::SBThread::GetProcess",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetProcess",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetProcess",1,SWIGTYPE_p_lldb__SBThread);
}
result = (arg1)->GetProcess();
{
lldb::SBProcess * resultptr = new lldb::SBProcess((const lldb::SBProcess &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetDescription__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBThread::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetDescription",1,"lldb::SBThread const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetDescription",1,SWIGTYPE_p_lldb__SBThread);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBThread_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)((lldb::SBThread const *)arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetDescription__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool arg3 ;
bool result;
SWIG_check_num_args("lldb::SBThread::GetDescription",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetDescription",1,"lldb::SBThread const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::GetDescription",2,"lldb::SBStream &");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBThread::GetDescription",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetDescription",1,SWIGTYPE_p_lldb__SBThread);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBThread_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
arg3 = (lua_toboolean(L, 3)!=0);
result = (bool)((lldb::SBThread const *)arg1)->GetDescription(*arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetDescription(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThread_GetDescription__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[2]);
}
if (_v) {
return _wrap_SBThread_GetDescription__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBThread_GetDescription'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBThread::GetDescription(lldb::SBStream &) const\n"
" lldb::SBThread::GetDescription(lldb::SBStream &,bool) const\n");
lua_error(L);return 0;
}
static int _wrap_SBThread_GetStatus(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBThread::GetStatus",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetStatus",1,"lldb::SBThread const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::GetStatus",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetStatus",1,SWIGTYPE_p_lldb__SBThread);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBThread_GetStatus",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)((lldb::SBThread const *)arg1)->GetStatus(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBThread *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBThread::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::operator ==",1,"lldb::SBThread const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::operator ==",2,"lldb::SBThread const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread___eq",1,SWIGTYPE_p_lldb__SBThread);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread___eq",2,SWIGTYPE_p_lldb__SBThread);
}
result = (bool)((lldb::SBThread const *)arg1)->operator ==((lldb::SBThread const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetExtendedBacktraceThread(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBThread result;
SWIG_check_num_args("lldb::SBThread::GetExtendedBacktraceThread",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetExtendedBacktraceThread",1,"lldb::SBThread *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThread::GetExtendedBacktraceThread",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetExtendedBacktraceThread",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->GetExtendedBacktraceThread((char const *)arg2);
{
lldb::SBThread * resultptr = new lldb::SBThread((const lldb::SBThread &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetExtendedBacktraceOriginatingIndexID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBThread::GetExtendedBacktraceOriginatingIndexID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetExtendedBacktraceOriginatingIndexID",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetExtendedBacktraceOriginatingIndexID",1,SWIGTYPE_p_lldb__SBThread);
}
result = (uint32_t)(arg1)->GetExtendedBacktraceOriginatingIndexID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetCurrentException(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBThread::GetCurrentException",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetCurrentException",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetCurrentException",1,SWIGTYPE_p_lldb__SBThread);
}
result = (arg1)->GetCurrentException();
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetCurrentExceptionBacktrace(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
lldb::SBThread result;
SWIG_check_num_args("lldb::SBThread::GetCurrentExceptionBacktrace",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetCurrentExceptionBacktrace",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetCurrentExceptionBacktrace",1,SWIGTYPE_p_lldb__SBThread);
}
result = (arg1)->GetCurrentExceptionBacktrace();
{
lldb::SBThread * resultptr = new lldb::SBThread((const lldb::SBThread &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_SafeToCallFunctions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBThread::SafeToCallFunctions",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::SafeToCallFunctions",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_SafeToCallFunctions",1,SWIGTYPE_p_lldb__SBThread);
}
result = (bool)(arg1)->SafeToCallFunctions();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread_GetSiginfo(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
- lldb::SBError *arg2 = 0 ;
lldb::SBValue result;
- SWIG_check_num_args("lldb::SBThread::GetSiginfo",2,2)
+ SWIG_check_num_args("lldb::SBThread::GetSiginfo",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetSiginfo",1,"lldb::SBThread *");
- if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::GetSiginfo",2,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread_GetSiginfo",1,SWIGTYPE_p_lldb__SBThread);
}
-
- if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
- SWIG_fail_ptr("SBThread_GetSiginfo",2,SWIGTYPE_p_lldb__SBError);
- }
-
- result = (arg1)->GetSiginfo(*arg2);
+ result = (arg1)->GetSiginfo();
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThread___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = (lldb::SBThread *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBThread::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::__str__",1,"lldb::SBThread *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBThread___tostring",1,SWIGTYPE_p_lldb__SBThread);
}
result = lldb_SBThread___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBThread(void *obj) {
lldb::SBThread *arg1 = (lldb::SBThread *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBThread(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBThread);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBThread_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBThread_methods[]= {
{ "IsValid", _wrap_SBThread_IsValid},
{ "Clear", _wrap_SBThread_Clear},
{ "GetStopReason", _wrap_SBThread_GetStopReason},
{ "GetStopReasonDataCount", _wrap_SBThread_GetStopReasonDataCount},
{ "GetStopReasonDataAtIndex", _wrap_SBThread_GetStopReasonDataAtIndex},
{ "GetStopReasonExtendedInfoAsJSON", _wrap_SBThread_GetStopReasonExtendedInfoAsJSON},
{ "GetStopReasonExtendedBacktraces", _wrap_SBThread_GetStopReasonExtendedBacktraces},
{ "GetStopDescription", _wrap_SBThread_GetStopDescription},
{ "GetStopReturnValue", _wrap_SBThread_GetStopReturnValue},
{ "GetThreadID", _wrap_SBThread_GetThreadID},
{ "GetIndexID", _wrap_SBThread_GetIndexID},
{ "GetName", _wrap_SBThread_GetName},
{ "GetQueueName", _wrap_SBThread_GetQueueName},
{ "GetQueueID", _wrap_SBThread_GetQueueID},
{ "GetInfoItemByPathAsString", _wrap_SBThread_GetInfoItemByPathAsString},
{ "GetQueue", _wrap_SBThread_GetQueue},
{ "StepOver", _wrap_SBThread_StepOver},
{ "StepInto", _wrap_SBThread_StepInto},
{ "StepOut", _wrap_SBThread_StepOut},
{ "StepOutOfFrame", _wrap_SBThread_StepOutOfFrame},
{ "StepInstruction", _wrap_SBThread_StepInstruction},
{ "StepOverUntil", _wrap_SBThread_StepOverUntil},
{ "StepUsingScriptedThreadPlan", _wrap_SBThread_StepUsingScriptedThreadPlan},
{ "JumpToLine", _wrap_SBThread_JumpToLine},
{ "RunToAddress", _wrap_SBThread_RunToAddress},
{ "ReturnFromFrame", _wrap_SBThread_ReturnFromFrame},
{ "UnwindInnermostExpression", _wrap_SBThread_UnwindInnermostExpression},
{ "Suspend", _wrap_SBThread_Suspend},
{ "Resume", _wrap_SBThread_Resume},
{ "IsSuspended", _wrap_SBThread_IsSuspended},
{ "IsStopped", _wrap_SBThread_IsStopped},
{ "GetNumFrames", _wrap_SBThread_GetNumFrames},
{ "GetFrameAtIndex", _wrap_SBThread_GetFrameAtIndex},
{ "GetSelectedFrame", _wrap_SBThread_GetSelectedFrame},
{ "SetSelectedFrame", _wrap_SBThread_SetSelectedFrame},
{ "GetProcess", _wrap_SBThread_GetProcess},
{ "GetDescription", _wrap_SBThread_GetDescription},
{ "GetStatus", _wrap_SBThread_GetStatus},
{ "__eq", _wrap_SBThread___eq},
{ "GetExtendedBacktraceThread", _wrap_SBThread_GetExtendedBacktraceThread},
{ "GetExtendedBacktraceOriginatingIndexID", _wrap_SBThread_GetExtendedBacktraceOriginatingIndexID},
{ "GetCurrentException", _wrap_SBThread_GetCurrentException},
{ "GetCurrentExceptionBacktrace", _wrap_SBThread_GetCurrentExceptionBacktrace},
{ "SafeToCallFunctions", _wrap_SBThread_SafeToCallFunctions},
{ "GetSiginfo", _wrap_SBThread_GetSiginfo},
{ "__tostring", _wrap_SBThread___tostring},
{0,0}
};
static swig_lua_method swig_SBThread_meta[] = {
{ "__eq", _wrap_SBThread___eq},
{ "__tostring", _wrap_SBThread___tostring},
{0,0}
};
static swig_lua_attribute swig_SBThread_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBThread_Sf_SwigStatic_constants[]= {
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitStackChanged", lldb::SBThread::eBroadcastBitStackChanged)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitThreadSuspended", lldb::SBThread::eBroadcastBitThreadSuspended)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitThreadResumed", lldb::SBThread::eBroadcastBitThreadResumed)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitSelectedFrameChanged", lldb::SBThread::eBroadcastBitSelectedFrameChanged)},
{SWIG_LUA_CONSTTAB_INT("eBroadcastBitThreadSelected", lldb::SBThread::eBroadcastBitThreadSelected)},
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBThread_Sf_SwigStatic_methods[]= {
{ "GetBroadcasterClassName", _wrap_SBThread_GetBroadcasterClassName},
{ "EventIsThreadEvent", _wrap_SBThread_EventIsThreadEvent},
{ "GetStackFrameFromEvent", _wrap_SBThread_GetStackFrameFromEvent},
{ "GetThreadFromEvent", _wrap_SBThread_GetThreadFromEvent},
{0,0}
};
static swig_lua_class* swig_SBThread_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBThread_Sf_SwigStatic = {
"SBThread",
swig_SBThread_Sf_SwigStatic_methods,
swig_SBThread_Sf_SwigStatic_attributes,
swig_SBThread_Sf_SwigStatic_constants,
swig_SBThread_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBThread_bases[] = {0};
static const char *swig_SBThread_base_names[] = {0};
static swig_lua_class _wrap_class_SBThread = { "SBThread", "SBThread", &SWIGTYPE_p_lldb__SBThread,_proxy__wrap_new_SBThread, swig_delete_SBThread, swig_SBThread_methods, swig_SBThread_attributes, &swig_SBThread_Sf_SwigStatic, swig_SBThread_meta, swig_SBThread_bases, swig_SBThread_base_names };
static int _wrap_new_SBThreadCollection__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadCollection *result = 0 ;
SWIG_check_num_args("lldb::SBThreadCollection::SBThreadCollection",0,0)
result = (lldb::SBThreadCollection *)new lldb::SBThreadCollection();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBThreadCollection,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBThreadCollection__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadCollection *arg1 = 0 ;
lldb::SBThreadCollection *result = 0 ;
SWIG_check_num_args("lldb::SBThreadCollection::SBThreadCollection",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBThreadCollection::SBThreadCollection",1,"lldb::SBThreadCollection const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadCollection,0))){
SWIG_fail_ptr("new_SBThreadCollection",1,SWIGTYPE_p_lldb__SBThreadCollection);
}
result = (lldb::SBThreadCollection *)new lldb::SBThreadCollection((lldb::SBThreadCollection const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBThreadCollection,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBThreadCollection(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBThreadCollection__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadCollection, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBThreadCollection__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBThreadCollection'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBThreadCollection::SBThreadCollection()\n"
" lldb::SBThreadCollection::SBThreadCollection(lldb::SBThreadCollection const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBThreadCollection_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadCollection *arg1 = (lldb::SBThreadCollection *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBThreadCollection::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadCollection::IsValid",1,"lldb::SBThreadCollection const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadCollection,0))){
SWIG_fail_ptr("SBThreadCollection_IsValid",1,SWIGTYPE_p_lldb__SBThreadCollection);
}
result = (bool)((lldb::SBThreadCollection const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadCollection_GetSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadCollection *arg1 = (lldb::SBThreadCollection *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBThreadCollection::GetSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadCollection::GetSize",1,"lldb::SBThreadCollection *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadCollection,0))){
SWIG_fail_ptr("SBThreadCollection_GetSize",1,SWIGTYPE_p_lldb__SBThreadCollection);
}
result = (arg1)->GetSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadCollection_GetThreadAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadCollection *arg1 = (lldb::SBThreadCollection *) 0 ;
size_t arg2 ;
lldb::SBThread result;
SWIG_check_num_args("lldb::SBThreadCollection::GetThreadAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadCollection::GetThreadAtIndex",1,"lldb::SBThreadCollection *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThreadCollection::GetThreadAtIndex",2,"size_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadCollection,0))){
SWIG_fail_ptr("SBThreadCollection_GetThreadAtIndex",1,SWIGTYPE_p_lldb__SBThreadCollection);
}
arg2 = (size_t)lua_tointeger(L, 2);
result = (arg1)->GetThreadAtIndex(arg2);
{
lldb::SBThread * resultptr = new lldb::SBThread((const lldb::SBThread &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBThreadCollection(void *obj) {
lldb::SBThreadCollection *arg1 = (lldb::SBThreadCollection *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBThreadCollection(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBThreadCollection);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBThreadCollection_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBThreadCollection_methods[]= {
{ "IsValid", _wrap_SBThreadCollection_IsValid},
{ "GetSize", _wrap_SBThreadCollection_GetSize},
{ "GetThreadAtIndex", _wrap_SBThreadCollection_GetThreadAtIndex},
{0,0}
};
static swig_lua_method swig_SBThreadCollection_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBThreadCollection_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBThreadCollection_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBThreadCollection_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBThreadCollection_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBThreadCollection_Sf_SwigStatic = {
"SBThreadCollection",
swig_SBThreadCollection_Sf_SwigStatic_methods,
swig_SBThreadCollection_Sf_SwigStatic_attributes,
swig_SBThreadCollection_Sf_SwigStatic_constants,
swig_SBThreadCollection_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBThreadCollection_bases[] = {0};
static const char *swig_SBThreadCollection_base_names[] = {0};
static swig_lua_class _wrap_class_SBThreadCollection = { "SBThreadCollection", "SBThreadCollection", &SWIGTYPE_p_lldb__SBThreadCollection,_proxy__wrap_new_SBThreadCollection, swig_delete_SBThreadCollection, swig_SBThreadCollection_methods, swig_SBThreadCollection_attributes, &swig_SBThreadCollection_Sf_SwigStatic, swig_SBThreadCollection_meta, swig_SBThreadCollection_bases, swig_SBThreadCollection_base_names };
static int _wrap_new_SBThreadPlan__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *result = 0 ;
SWIG_check_num_args("lldb::SBThreadPlan::SBThreadPlan",0,0)
result = (lldb::SBThreadPlan *)new lldb::SBThreadPlan();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBThreadPlan__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = 0 ;
lldb::SBThreadPlan *result = 0 ;
SWIG_check_num_args("lldb::SBThreadPlan::SBThreadPlan",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::SBThreadPlan",1,"lldb::SBThreadPlan const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("new_SBThreadPlan",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
result = (lldb::SBThreadPlan *)new lldb::SBThreadPlan((lldb::SBThreadPlan const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBThreadPlan__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::ThreadPlanSP *arg1 = 0 ;
lldb::SBThreadPlan *result = 0 ;
SWIG_check_num_args("lldb::SBThreadPlan::SBThreadPlan",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::SBThreadPlan",1,"lldb::ThreadPlanSP const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPlan_t,0))){
SWIG_fail_ptr("new_SBThreadPlan",1,SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPlan_t);
}
result = (lldb::SBThreadPlan *)new lldb::SBThreadPlan((lldb::ThreadPlanSP const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBThreadPlan__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThread *arg1 = 0 ;
char *arg2 = (char *) 0 ;
lldb::SBThreadPlan *result = 0 ;
SWIG_check_num_args("lldb::SBThreadPlan::SBThreadPlan",2,2)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::SBThreadPlan",1,"lldb::SBThread &");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::SBThreadPlan",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("new_SBThreadPlan",1,SWIGTYPE_p_lldb__SBThread);
}
arg2 = (char *)lua_tostring(L, 2);
result = (lldb::SBThreadPlan *)new lldb::SBThreadPlan(*arg1,(char const *)arg2);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBThreadPlan(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBThreadPlan__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBThreadPlan__SWIG_1(L);
}
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPlan_t, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBThreadPlan__SWIG_2(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_new_SBThreadPlan__SWIG_3(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBThreadPlan'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBThreadPlan::SBThreadPlan()\n"
" lldb::SBThreadPlan::SBThreadPlan(lldb::SBThreadPlan const &)\n"
" lldb::SBThreadPlan::SBThreadPlan(lldb::ThreadPlanSP const &)\n"
" lldb::SBThreadPlan::SBThreadPlan(lldb::SBThread &,char const *)\n");
lua_error(L);return 0;
}
static int _wrap_SBThreadPlan_IsValid__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBThreadPlan::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::IsValid",1,"lldb::SBThreadPlan *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_IsValid",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
result = (bool)(arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_IsValid__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBThreadPlan::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::IsValid",1,"lldb::SBThreadPlan const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_IsValid",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
result = (bool)((lldb::SBThreadPlan const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_IsValid(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThreadPlan_IsValid__SWIG_0(L);
}
}
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThreadPlan_IsValid__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBThreadPlan_IsValid'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBThreadPlan::IsValid()\n"
" lldb::SBThreadPlan::IsValid() const\n");
lua_error(L);return 0;
}
static int _wrap_SBThreadPlan_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
SWIG_check_num_args("lldb::SBThreadPlan::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::Clear",1,"lldb::SBThreadPlan *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_Clear",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_GetStopReason(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
lldb::StopReason result;
SWIG_check_num_args("lldb::SBThreadPlan::GetStopReason",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::GetStopReason",1,"lldb::SBThreadPlan *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_GetStopReason",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
result = (lldb::StopReason)(arg1)->GetStopReason();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_GetStopReasonDataCount(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBThreadPlan::GetStopReasonDataCount",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::GetStopReasonDataCount",1,"lldb::SBThreadPlan *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_GetStopReasonDataCount",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
result = (arg1)->GetStopReasonDataCount();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_GetStopReasonDataAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
uint32_t arg2 ;
uint64_t result;
SWIG_check_num_args("lldb::SBThreadPlan::GetStopReasonDataAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::GetStopReasonDataAtIndex",1,"lldb::SBThreadPlan *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::GetStopReasonDataAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_GetStopReasonDataAtIndex",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (uint64_t)(arg1)->GetStopReasonDataAtIndex(arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_GetThread(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
lldb::SBThread result;
SWIG_check_num_args("lldb::SBThreadPlan::GetThread",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::GetThread",1,"lldb::SBThreadPlan const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_GetThread",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
result = ((lldb::SBThreadPlan const *)arg1)->GetThread();
{
lldb::SBThread * resultptr = new lldb::SBThread((const lldb::SBThread &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBThreadPlan::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::GetDescription",1,"lldb::SBThreadPlan const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_GetDescription",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBThreadPlan_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)((lldb::SBThreadPlan const *)arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_SetPlanComplete(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBThreadPlan::SetPlanComplete",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::SetPlanComplete",1,"lldb::SBThreadPlan *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::SetPlanComplete",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_SetPlanComplete",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetPlanComplete(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_IsPlanComplete(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBThreadPlan::IsPlanComplete",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::IsPlanComplete",1,"lldb::SBThreadPlan *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_IsPlanComplete",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
result = (bool)(arg1)->IsPlanComplete();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_IsPlanStale(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBThreadPlan::IsPlanStale",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::IsPlanStale",1,"lldb::SBThreadPlan *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_IsPlanStale",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
result = (bool)(arg1)->IsPlanStale();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_GetStopOthers(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBThreadPlan::GetStopOthers",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::GetStopOthers",1,"lldb::SBThreadPlan *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_GetStopOthers",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
result = (bool)(arg1)->GetStopOthers();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_SetStopOthers(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBThreadPlan::SetStopOthers",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::SetStopOthers",1,"lldb::SBThreadPlan *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::SetStopOthers",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_SetStopOthers",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetStopOthers(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_QueueThreadPlanForStepOverRange(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
lldb::SBAddress *arg2 = 0 ;
lldb::addr_t arg3 ;
lldb::SBThreadPlan result;
SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForStepOverRange",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOverRange",1,"lldb::SBThreadPlan *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOverRange",2,"lldb::SBAddress &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOverRange",3,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepOverRange",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepOverRange",2,SWIGTYPE_p_lldb__SBAddress);
}
arg3 = (lldb::addr_t)lua_tointeger(L, 3);
result = (arg1)->QueueThreadPlanForStepOverRange(*arg2,arg3);
{
lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan((const lldb::SBThreadPlan &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_QueueThreadPlanForStepInRange(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
lldb::SBAddress *arg2 = 0 ;
lldb::addr_t arg3 ;
lldb::SBThreadPlan result;
SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForStepInRange",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepInRange",1,"lldb::SBThreadPlan *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepInRange",2,"lldb::SBAddress &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepInRange",3,"lldb::addr_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepInRange",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepInRange",2,SWIGTYPE_p_lldb__SBAddress);
}
arg3 = (lldb::addr_t)lua_tointeger(L, 3);
result = (arg1)->QueueThreadPlanForStepInRange(*arg2,arg3);
{
lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan((const lldb::SBThreadPlan &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
uint32_t arg2 ;
bool arg3 ;
lldb::SBThreadPlan result;
SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForStepOut",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOut",1,"lldb::SBThreadPlan *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOut",2,"uint32_t");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOut",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepOut",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
arg3 = (lua_toboolean(L, 3)!=0);
result = (arg1)->QueueThreadPlanForStepOut(arg2,arg3);
{
lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan((const lldb::SBThreadPlan &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
uint32_t arg2 ;
lldb::SBThreadPlan result;
SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForStepOut",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOut",1,"lldb::SBThreadPlan *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOut",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepOut",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->QueueThreadPlanForStepOut(arg2);
{
lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan((const lldb::SBThreadPlan &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_QueueThreadPlanForStepOut(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_1(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[2]);
}
if (_v) {
return _wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_0(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBThreadPlan_QueueThreadPlanForStepOut'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBThreadPlan::QueueThreadPlanForStepOut(uint32_t,bool)\n"
" lldb::SBThreadPlan::QueueThreadPlanForStepOut(uint32_t)\n");
lua_error(L);return 0;
}
static int _wrap_SBThreadPlan_QueueThreadPlanForRunToAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
lldb::SBAddress arg2 ;
lldb::SBAddress *argp2 ;
lldb::SBThreadPlan result;
SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForRunToAddress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForRunToAddress",1,"lldb::SBThreadPlan *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForRunToAddress",2,"lldb::SBAddress");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForRunToAddress",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBAddress,0))){
SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForRunToAddress",2,SWIGTYPE_p_lldb__SBAddress);
}
arg2 = *argp2;
result = (arg1)->QueueThreadPlanForRunToAddress(arg2);
{
lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan((const lldb::SBThreadPlan &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBThreadPlan result;
SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",1,"lldb::SBThreadPlan *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepScripted",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->QueueThreadPlanForStepScripted((char const *)arg2);
{
lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan((const lldb::SBThreadPlan &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBError *arg3 = 0 ;
lldb::SBThreadPlan result;
SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",1,"lldb::SBThreadPlan *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",3,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepScripted",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepScripted",3,SWIGTYPE_p_lldb__SBError);
}
result = (arg1)->QueueThreadPlanForStepScripted((char const *)arg2,*arg3);
{
lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan((const lldb::SBThreadPlan &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBStructuredData *arg3 = 0 ;
lldb::SBError *arg4 = 0 ;
lldb::SBThreadPlan result;
SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",1,"lldb::SBThreadPlan *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",3,"lldb::SBStructuredData &");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",4,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){
SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepScripted",1,SWIGTYPE_p_lldb__SBThreadPlan);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepScripted",3,SWIGTYPE_p_lldb__SBStructuredData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepScripted",4,SWIGTYPE_p_lldb__SBError);
}
result = (arg1)->QueueThreadPlanForStepScripted((char const *)arg2,*arg3,*arg4);
{
lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan((const lldb::SBThreadPlan &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBThreadPlan_QueueThreadPlanForStepScripted(lua_State* L) {
int argc;
int argv[5]={
1,2,3,4,5
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_1(L);
}
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_2(L);
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBThreadPlan_QueueThreadPlanForStepScripted'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBThreadPlan::QueueThreadPlanForStepScripted(char const *)\n"
" lldb::SBThreadPlan::QueueThreadPlanForStepScripted(char const *,lldb::SBError &)\n"
" lldb::SBThreadPlan::QueueThreadPlanForStepScripted(char const *,lldb::SBStructuredData &,lldb::SBError &)\n");
lua_error(L);return 0;
}
static void swig_delete_SBThreadPlan(void *obj) {
lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBThreadPlan(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBThreadPlan);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBThreadPlan_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBThreadPlan_methods[]= {
{ "IsValid", _wrap_SBThreadPlan_IsValid},
{ "Clear", _wrap_SBThreadPlan_Clear},
{ "GetStopReason", _wrap_SBThreadPlan_GetStopReason},
{ "GetStopReasonDataCount", _wrap_SBThreadPlan_GetStopReasonDataCount},
{ "GetStopReasonDataAtIndex", _wrap_SBThreadPlan_GetStopReasonDataAtIndex},
{ "GetThread", _wrap_SBThreadPlan_GetThread},
{ "GetDescription", _wrap_SBThreadPlan_GetDescription},
{ "SetPlanComplete", _wrap_SBThreadPlan_SetPlanComplete},
{ "IsPlanComplete", _wrap_SBThreadPlan_IsPlanComplete},
{ "IsPlanStale", _wrap_SBThreadPlan_IsPlanStale},
{ "GetStopOthers", _wrap_SBThreadPlan_GetStopOthers},
{ "SetStopOthers", _wrap_SBThreadPlan_SetStopOthers},
{ "QueueThreadPlanForStepOverRange", _wrap_SBThreadPlan_QueueThreadPlanForStepOverRange},
{ "QueueThreadPlanForStepInRange", _wrap_SBThreadPlan_QueueThreadPlanForStepInRange},
{ "QueueThreadPlanForStepOut", _wrap_SBThreadPlan_QueueThreadPlanForStepOut},
{ "QueueThreadPlanForRunToAddress", _wrap_SBThreadPlan_QueueThreadPlanForRunToAddress},
{ "QueueThreadPlanForStepScripted", _wrap_SBThreadPlan_QueueThreadPlanForStepScripted},
{0,0}
};
static swig_lua_method swig_SBThreadPlan_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBThreadPlan_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBThreadPlan_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBThreadPlan_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBThreadPlan_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBThreadPlan_Sf_SwigStatic = {
"SBThreadPlan",
swig_SBThreadPlan_Sf_SwigStatic_methods,
swig_SBThreadPlan_Sf_SwigStatic_attributes,
swig_SBThreadPlan_Sf_SwigStatic_constants,
swig_SBThreadPlan_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBThreadPlan_bases[] = {0};
static const char *swig_SBThreadPlan_base_names[] = {0};
static swig_lua_class _wrap_class_SBThreadPlan = { "SBThreadPlan", "SBThreadPlan", &SWIGTYPE_p_lldb__SBThreadPlan,_proxy__wrap_new_SBThreadPlan, swig_delete_SBThreadPlan, swig_SBThreadPlan_methods, swig_SBThreadPlan_attributes, &swig_SBThreadPlan_Sf_SwigStatic, swig_SBThreadPlan_meta, swig_SBThreadPlan_bases, swig_SBThreadPlan_base_names };
static int _wrap_new_SBTrace(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTrace *result = 0 ;
SWIG_check_num_args("lldb::SBTrace::SBTrace",0,0)
result = (lldb::SBTrace *)new lldb::SBTrace();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTrace,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTrace_GetStartConfigurationHelp(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBTrace::GetStartConfigurationHelp",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTrace::GetStartConfigurationHelp",1,"lldb::SBTrace *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTrace,0))){
SWIG_fail_ptr("SBTrace_GetStartConfigurationHelp",1,SWIGTYPE_p_lldb__SBTrace);
}
result = (char *)(arg1)->GetStartConfigurationHelp();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTrace_Start__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ;
lldb::SBStructuredData *arg2 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBTrace::Start",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTrace::Start",1,"lldb::SBTrace *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTrace::Start",2,"lldb::SBStructuredData const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTrace,0))){
SWIG_fail_ptr("SBTrace_Start",1,SWIGTYPE_p_lldb__SBTrace);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBTrace_Start",2,SWIGTYPE_p_lldb__SBStructuredData);
}
result = (arg1)->Start((lldb::SBStructuredData const &)*arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTrace_Start__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ;
lldb::SBThread *arg2 = 0 ;
lldb::SBStructuredData *arg3 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBTrace::Start",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTrace::Start",1,"lldb::SBTrace *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTrace::Start",2,"lldb::SBThread const &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTrace::Start",3,"lldb::SBStructuredData const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTrace,0))){
SWIG_fail_ptr("SBTrace_Start",1,SWIGTYPE_p_lldb__SBTrace);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBTrace_Start",2,SWIGTYPE_p_lldb__SBThread);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStructuredData,0))){
SWIG_fail_ptr("SBTrace_Start",3,SWIGTYPE_p_lldb__SBStructuredData);
}
result = (arg1)->Start((lldb::SBThread const &)*arg2,(lldb::SBStructuredData const &)*arg3);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTrace_Start(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTrace, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTrace_Start__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTrace, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTrace_Start__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTrace_Start'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTrace::Start(lldb::SBStructuredData const &)\n"
" lldb::SBTrace::Start(lldb::SBThread const &,lldb::SBStructuredData const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTrace_Stop__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBTrace::Stop",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTrace::Stop",1,"lldb::SBTrace *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTrace,0))){
SWIG_fail_ptr("SBTrace_Stop",1,SWIGTYPE_p_lldb__SBTrace);
}
result = (arg1)->Stop();
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTrace_Stop__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ;
lldb::SBThread *arg2 = 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBTrace::Stop",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTrace::Stop",1,"lldb::SBTrace *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTrace::Stop",2,"lldb::SBThread const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTrace,0))){
SWIG_fail_ptr("SBTrace_Stop",1,SWIGTYPE_p_lldb__SBTrace);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBThread,0))){
SWIG_fail_ptr("SBTrace_Stop",2,SWIGTYPE_p_lldb__SBThread);
}
result = (arg1)->Stop((lldb::SBThread const &)*arg2);
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTrace_Stop(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTrace, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTrace_Stop__SWIG_0(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTrace, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBTrace_Stop__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTrace_Stop'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTrace::Stop()\n"
" lldb::SBTrace::Stop(lldb::SBThread const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTrace_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTrace::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTrace::IsValid",1,"lldb::SBTrace *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTrace,0))){
SWIG_fail_ptr("SBTrace_IsValid",1,SWIGTYPE_p_lldb__SBTrace);
}
result = (bool)(arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBTrace(void *obj) {
lldb::SBTrace *arg1 = (lldb::SBTrace *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBTrace(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBTrace);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBTrace_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBTrace_methods[]= {
{ "GetStartConfigurationHelp", _wrap_SBTrace_GetStartConfigurationHelp},
{ "Start", _wrap_SBTrace_Start},
{ "Stop", _wrap_SBTrace_Stop},
{ "IsValid", _wrap_SBTrace_IsValid},
{0,0}
};
static swig_lua_method swig_SBTrace_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBTrace_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBTrace_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBTrace_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBTrace_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBTrace_Sf_SwigStatic = {
"SBTrace",
swig_SBTrace_Sf_SwigStatic_methods,
swig_SBTrace_Sf_SwigStatic_attributes,
swig_SBTrace_Sf_SwigStatic_constants,
swig_SBTrace_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBTrace_bases[] = {0};
static const char *swig_SBTrace_base_names[] = {0};
static swig_lua_class _wrap_class_SBTrace = { "SBTrace", "SBTrace", &SWIGTYPE_p_lldb__SBTrace,_proxy__wrap_new_SBTrace, swig_delete_SBTrace, swig_SBTrace_methods, swig_SBTrace_attributes, &swig_SBTrace_Sf_SwigStatic, swig_SBTrace_meta, swig_SBTrace_bases, swig_SBTrace_base_names };
static int _wrap_new_SBTypeMember__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMember *result = 0 ;
SWIG_check_num_args("lldb::SBTypeMember::SBTypeMember",0,0)
result = (lldb::SBTypeMember *)new lldb::SBTypeMember();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeMember,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeMember__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMember *arg1 = 0 ;
lldb::SBTypeMember *result = 0 ;
SWIG_check_num_args("lldb::SBTypeMember::SBTypeMember",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeMember::SBTypeMember",1,"lldb::SBTypeMember const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){
SWIG_fail_ptr("new_SBTypeMember",1,SWIGTYPE_p_lldb__SBTypeMember);
}
result = (lldb::SBTypeMember *)new lldb::SBTypeMember((lldb::SBTypeMember const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeMember,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeMember(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBTypeMember__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeMember, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBTypeMember__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeMember'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTypeMember::SBTypeMember()\n"
" lldb::SBTypeMember::SBTypeMember(lldb::SBTypeMember const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTypeMember_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeMember::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMember::IsValid",1,"lldb::SBTypeMember const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){
SWIG_fail_ptr("SBTypeMember_IsValid",1,SWIGTYPE_p_lldb__SBTypeMember);
}
result = (bool)((lldb::SBTypeMember const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeMember_GetName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBTypeMember::GetName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMember::GetName",1,"lldb::SBTypeMember *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){
SWIG_fail_ptr("SBTypeMember_GetName",1,SWIGTYPE_p_lldb__SBTypeMember);
}
result = (char *)(arg1)->GetName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeMember_GetType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBTypeMember::GetType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMember::GetType",1,"lldb::SBTypeMember *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){
SWIG_fail_ptr("SBTypeMember_GetType",1,SWIGTYPE_p_lldb__SBTypeMember);
}
result = (arg1)->GetType();
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeMember_GetOffsetInBytes(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ;
uint64_t result;
SWIG_check_num_args("lldb::SBTypeMember::GetOffsetInBytes",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMember::GetOffsetInBytes",1,"lldb::SBTypeMember *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){
SWIG_fail_ptr("SBTypeMember_GetOffsetInBytes",1,SWIGTYPE_p_lldb__SBTypeMember);
}
result = (uint64_t)(arg1)->GetOffsetInBytes();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeMember_GetOffsetInBits(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ;
uint64_t result;
SWIG_check_num_args("lldb::SBTypeMember::GetOffsetInBits",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMember::GetOffsetInBits",1,"lldb::SBTypeMember *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){
SWIG_fail_ptr("SBTypeMember_GetOffsetInBits",1,SWIGTYPE_p_lldb__SBTypeMember);
}
result = (uint64_t)(arg1)->GetOffsetInBits();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeMember_IsBitfield(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeMember::IsBitfield",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMember::IsBitfield",1,"lldb::SBTypeMember *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){
SWIG_fail_ptr("SBTypeMember_IsBitfield",1,SWIGTYPE_p_lldb__SBTypeMember);
}
result = (bool)(arg1)->IsBitfield();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeMember_GetBitfieldSizeInBits(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTypeMember::GetBitfieldSizeInBits",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMember::GetBitfieldSizeInBits",1,"lldb::SBTypeMember *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){
SWIG_fail_ptr("SBTypeMember_GetBitfieldSizeInBits",1,SWIGTYPE_p_lldb__SBTypeMember);
}
result = (uint32_t)(arg1)->GetBitfieldSizeInBits();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeMember___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBTypeMember::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMember::__str__",1,"lldb::SBTypeMember *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){
SWIG_fail_ptr("SBTypeMember___tostring",1,SWIGTYPE_p_lldb__SBTypeMember);
}
result = lldb_SBTypeMember___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBTypeMember(void *obj) {
lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBTypeMember(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBTypeMember);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBTypeMember_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBTypeMember_methods[]= {
{ "IsValid", _wrap_SBTypeMember_IsValid},
{ "GetName", _wrap_SBTypeMember_GetName},
{ "GetType", _wrap_SBTypeMember_GetType},
{ "GetOffsetInBytes", _wrap_SBTypeMember_GetOffsetInBytes},
{ "GetOffsetInBits", _wrap_SBTypeMember_GetOffsetInBits},
{ "IsBitfield", _wrap_SBTypeMember_IsBitfield},
{ "GetBitfieldSizeInBits", _wrap_SBTypeMember_GetBitfieldSizeInBits},
{ "__tostring", _wrap_SBTypeMember___tostring},
{0,0}
};
static swig_lua_method swig_SBTypeMember_meta[] = {
{ "__tostring", _wrap_SBTypeMember___tostring},
{0,0}
};
static swig_lua_attribute swig_SBTypeMember_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBTypeMember_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBTypeMember_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBTypeMember_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBTypeMember_Sf_SwigStatic = {
"SBTypeMember",
swig_SBTypeMember_Sf_SwigStatic_methods,
swig_SBTypeMember_Sf_SwigStatic_attributes,
swig_SBTypeMember_Sf_SwigStatic_constants,
swig_SBTypeMember_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBTypeMember_bases[] = {0};
static const char *swig_SBTypeMember_base_names[] = {0};
static swig_lua_class _wrap_class_SBTypeMember = { "SBTypeMember", "SBTypeMember", &SWIGTYPE_p_lldb__SBTypeMember,_proxy__wrap_new_SBTypeMember, swig_delete_SBTypeMember, swig_SBTypeMember_methods, swig_SBTypeMember_attributes, &swig_SBTypeMember_Sf_SwigStatic, swig_SBTypeMember_meta, swig_SBTypeMember_bases, swig_SBTypeMember_base_names };
static int _wrap_new_SBTypeMemberFunction__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMemberFunction *result = 0 ;
SWIG_check_num_args("lldb::SBTypeMemberFunction::SBTypeMemberFunction",0,0)
result = (lldb::SBTypeMemberFunction *)new lldb::SBTypeMemberFunction();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeMemberFunction,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeMemberFunction__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMemberFunction *arg1 = 0 ;
lldb::SBTypeMemberFunction *result = 0 ;
SWIG_check_num_args("lldb::SBTypeMemberFunction::SBTypeMemberFunction",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::SBTypeMemberFunction",1,"lldb::SBTypeMemberFunction const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){
SWIG_fail_ptr("new_SBTypeMemberFunction",1,SWIGTYPE_p_lldb__SBTypeMemberFunction);
}
result = (lldb::SBTypeMemberFunction *)new lldb::SBTypeMemberFunction((lldb::SBTypeMemberFunction const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeMemberFunction,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeMemberFunction(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBTypeMemberFunction__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeMemberFunction, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBTypeMemberFunction__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeMemberFunction'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTypeMemberFunction::SBTypeMemberFunction()\n"
" lldb::SBTypeMemberFunction::SBTypeMemberFunction(lldb::SBTypeMemberFunction const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTypeMemberFunction_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeMemberFunction::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::IsValid",1,"lldb::SBTypeMemberFunction const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){
SWIG_fail_ptr("SBTypeMemberFunction_IsValid",1,SWIGTYPE_p_lldb__SBTypeMemberFunction);
}
result = (bool)((lldb::SBTypeMemberFunction const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeMemberFunction_GetName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBTypeMemberFunction::GetName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetName",1,"lldb::SBTypeMemberFunction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){
SWIG_fail_ptr("SBTypeMemberFunction_GetName",1,SWIGTYPE_p_lldb__SBTypeMemberFunction);
}
result = (char *)(arg1)->GetName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeMemberFunction_GetDemangledName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBTypeMemberFunction::GetDemangledName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetDemangledName",1,"lldb::SBTypeMemberFunction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){
SWIG_fail_ptr("SBTypeMemberFunction_GetDemangledName",1,SWIGTYPE_p_lldb__SBTypeMemberFunction);
}
result = (char *)(arg1)->GetDemangledName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeMemberFunction_GetMangledName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBTypeMemberFunction::GetMangledName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetMangledName",1,"lldb::SBTypeMemberFunction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){
SWIG_fail_ptr("SBTypeMemberFunction_GetMangledName",1,SWIGTYPE_p_lldb__SBTypeMemberFunction);
}
result = (char *)(arg1)->GetMangledName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeMemberFunction_GetType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBTypeMemberFunction::GetType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetType",1,"lldb::SBTypeMemberFunction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){
SWIG_fail_ptr("SBTypeMemberFunction_GetType",1,SWIGTYPE_p_lldb__SBTypeMemberFunction);
}
result = (arg1)->GetType();
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeMemberFunction_GetReturnType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBTypeMemberFunction::GetReturnType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetReturnType",1,"lldb::SBTypeMemberFunction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){
SWIG_fail_ptr("SBTypeMemberFunction_GetReturnType",1,SWIGTYPE_p_lldb__SBTypeMemberFunction);
}
result = (arg1)->GetReturnType();
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeMemberFunction_GetNumberOfArguments(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTypeMemberFunction::GetNumberOfArguments",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetNumberOfArguments",1,"lldb::SBTypeMemberFunction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){
SWIG_fail_ptr("SBTypeMemberFunction_GetNumberOfArguments",1,SWIGTYPE_p_lldb__SBTypeMemberFunction);
}
result = (uint32_t)(arg1)->GetNumberOfArguments();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeMemberFunction_GetArgumentTypeAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ;
uint32_t arg2 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBTypeMemberFunction::GetArgumentTypeAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetArgumentTypeAtIndex",1,"lldb::SBTypeMemberFunction *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetArgumentTypeAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){
SWIG_fail_ptr("SBTypeMemberFunction_GetArgumentTypeAtIndex",1,SWIGTYPE_p_lldb__SBTypeMemberFunction);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetArgumentTypeAtIndex(arg2);
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeMemberFunction_GetKind(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ;
lldb::MemberFunctionKind result;
SWIG_check_num_args("lldb::SBTypeMemberFunction::GetKind",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetKind",1,"lldb::SBTypeMemberFunction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){
SWIG_fail_ptr("SBTypeMemberFunction_GetKind",1,SWIGTYPE_p_lldb__SBTypeMemberFunction);
}
result = (lldb::MemberFunctionKind)(arg1)->GetKind();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeMemberFunction_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ;
lldb::SBStream *arg2 = 0 ;
lldb::DescriptionLevel arg3 ;
bool result;
SWIG_check_num_args("lldb::SBTypeMemberFunction::GetDescription",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetDescription",1,"lldb::SBTypeMemberFunction *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetDescription",2,"lldb::SBStream &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetDescription",3,"lldb::DescriptionLevel");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){
SWIG_fail_ptr("SBTypeMemberFunction_GetDescription",1,SWIGTYPE_p_lldb__SBTypeMemberFunction);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBTypeMemberFunction_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3);
result = (bool)(arg1)->GetDescription(*arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeMemberFunction___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBTypeMemberFunction::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::__str__",1,"lldb::SBTypeMemberFunction *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){
SWIG_fail_ptr("SBTypeMemberFunction___tostring",1,SWIGTYPE_p_lldb__SBTypeMemberFunction);
}
result = lldb_SBTypeMemberFunction___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBTypeMemberFunction(void *obj) {
lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBTypeMemberFunction(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBTypeMemberFunction);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBTypeMemberFunction_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBTypeMemberFunction_methods[]= {
{ "IsValid", _wrap_SBTypeMemberFunction_IsValid},
{ "GetName", _wrap_SBTypeMemberFunction_GetName},
{ "GetDemangledName", _wrap_SBTypeMemberFunction_GetDemangledName},
{ "GetMangledName", _wrap_SBTypeMemberFunction_GetMangledName},
{ "GetType", _wrap_SBTypeMemberFunction_GetType},
{ "GetReturnType", _wrap_SBTypeMemberFunction_GetReturnType},
{ "GetNumberOfArguments", _wrap_SBTypeMemberFunction_GetNumberOfArguments},
{ "GetArgumentTypeAtIndex", _wrap_SBTypeMemberFunction_GetArgumentTypeAtIndex},
{ "GetKind", _wrap_SBTypeMemberFunction_GetKind},
{ "GetDescription", _wrap_SBTypeMemberFunction_GetDescription},
{ "__tostring", _wrap_SBTypeMemberFunction___tostring},
{0,0}
};
static swig_lua_method swig_SBTypeMemberFunction_meta[] = {
{ "__tostring", _wrap_SBTypeMemberFunction___tostring},
{0,0}
};
static swig_lua_attribute swig_SBTypeMemberFunction_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBTypeMemberFunction_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBTypeMemberFunction_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBTypeMemberFunction_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBTypeMemberFunction_Sf_SwigStatic = {
"SBTypeMemberFunction",
swig_SBTypeMemberFunction_Sf_SwigStatic_methods,
swig_SBTypeMemberFunction_Sf_SwigStatic_attributes,
swig_SBTypeMemberFunction_Sf_SwigStatic_constants,
swig_SBTypeMemberFunction_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBTypeMemberFunction_bases[] = {0};
static const char *swig_SBTypeMemberFunction_base_names[] = {0};
static swig_lua_class _wrap_class_SBTypeMemberFunction = { "SBTypeMemberFunction", "SBTypeMemberFunction", &SWIGTYPE_p_lldb__SBTypeMemberFunction,_proxy__wrap_new_SBTypeMemberFunction, swig_delete_SBTypeMemberFunction, swig_SBTypeMemberFunction_methods, swig_SBTypeMemberFunction_attributes, &swig_SBTypeMemberFunction_Sf_SwigStatic, swig_SBTypeMemberFunction_meta, swig_SBTypeMemberFunction_bases, swig_SBTypeMemberFunction_base_names };
static int _wrap_new_SBType__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *result = 0 ;
SWIG_check_num_args("lldb::SBType::SBType",0,0)
result = (lldb::SBType *)new lldb::SBType();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBType__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = 0 ;
lldb::SBType *result = 0 ;
SWIG_check_num_args("lldb::SBType::SBType",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBType::SBType",1,"lldb::SBType const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("new_SBType",1,SWIGTYPE_p_lldb__SBType);
}
result = (lldb::SBType *)new lldb::SBType((lldb::SBType const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBType(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBType__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBType, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBType__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBType'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBType::SBType()\n"
" lldb::SBType::SBType(lldb::SBType const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBType_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBType::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsValid",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_IsValid",1,SWIGTYPE_p_lldb__SBType);
}
result = (bool)(arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetByteSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
uint64_t result;
SWIG_check_num_args("lldb::SBType::GetByteSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetByteSize",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetByteSize",1,SWIGTYPE_p_lldb__SBType);
}
result = (uint64_t)(arg1)->GetByteSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_IsPointerType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBType::IsPointerType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsPointerType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_IsPointerType",1,SWIGTYPE_p_lldb__SBType);
}
result = (bool)(arg1)->IsPointerType();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_IsReferenceType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBType::IsReferenceType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsReferenceType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_IsReferenceType",1,SWIGTYPE_p_lldb__SBType);
}
result = (bool)(arg1)->IsReferenceType();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_IsFunctionType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBType::IsFunctionType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsFunctionType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_IsFunctionType",1,SWIGTYPE_p_lldb__SBType);
}
result = (bool)(arg1)->IsFunctionType();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_IsPolymorphicClass(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBType::IsPolymorphicClass",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsPolymorphicClass",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_IsPolymorphicClass",1,SWIGTYPE_p_lldb__SBType);
}
result = (bool)(arg1)->IsPolymorphicClass();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_IsArrayType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBType::IsArrayType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsArrayType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_IsArrayType",1,SWIGTYPE_p_lldb__SBType);
}
result = (bool)(arg1)->IsArrayType();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_IsVectorType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBType::IsVectorType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsVectorType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_IsVectorType",1,SWIGTYPE_p_lldb__SBType);
}
result = (bool)(arg1)->IsVectorType();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_IsTypedefType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBType::IsTypedefType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsTypedefType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_IsTypedefType",1,SWIGTYPE_p_lldb__SBType);
}
result = (bool)(arg1)->IsTypedefType();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_IsAnonymousType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBType::IsAnonymousType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsAnonymousType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_IsAnonymousType",1,SWIGTYPE_p_lldb__SBType);
}
result = (bool)(arg1)->IsAnonymousType();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_IsScopedEnumerationType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBType::IsScopedEnumerationType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsScopedEnumerationType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_IsScopedEnumerationType",1,SWIGTYPE_p_lldb__SBType);
}
result = (bool)(arg1)->IsScopedEnumerationType();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetPointerType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBType::GetPointerType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetPointerType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetPointerType",1,SWIGTYPE_p_lldb__SBType);
}
result = (arg1)->GetPointerType();
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetPointeeType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBType::GetPointeeType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetPointeeType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetPointeeType",1,SWIGTYPE_p_lldb__SBType);
}
result = (arg1)->GetPointeeType();
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetReferenceType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBType::GetReferenceType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetReferenceType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetReferenceType",1,SWIGTYPE_p_lldb__SBType);
}
result = (arg1)->GetReferenceType();
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetTypedefedType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBType::GetTypedefedType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetTypedefedType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetTypedefedType",1,SWIGTYPE_p_lldb__SBType);
}
result = (arg1)->GetTypedefedType();
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetDereferencedType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBType::GetDereferencedType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetDereferencedType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetDereferencedType",1,SWIGTYPE_p_lldb__SBType);
}
result = (arg1)->GetDereferencedType();
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetUnqualifiedType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBType::GetUnqualifiedType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetUnqualifiedType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetUnqualifiedType",1,SWIGTYPE_p_lldb__SBType);
}
result = (arg1)->GetUnqualifiedType();
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetCanonicalType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBType::GetCanonicalType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetCanonicalType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetCanonicalType",1,SWIGTYPE_p_lldb__SBType);
}
result = (arg1)->GetCanonicalType();
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetEnumerationIntegerType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBType::GetEnumerationIntegerType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetEnumerationIntegerType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetEnumerationIntegerType",1,SWIGTYPE_p_lldb__SBType);
}
result = (arg1)->GetEnumerationIntegerType();
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetArrayElementType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBType::GetArrayElementType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetArrayElementType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetArrayElementType",1,SWIGTYPE_p_lldb__SBType);
}
result = (arg1)->GetArrayElementType();
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetArrayType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
uint64_t arg2 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBType::GetArrayType",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetArrayType",1,"lldb::SBType *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBType::GetArrayType",2,"uint64_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetArrayType",1,SWIGTYPE_p_lldb__SBType);
}
arg2 = (uint64_t)lua_tointeger(L, 2);
result = (arg1)->GetArrayType(arg2);
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetVectorElementType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBType::GetVectorElementType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetVectorElementType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetVectorElementType",1,SWIGTYPE_p_lldb__SBType);
}
result = (arg1)->GetVectorElementType();
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetBasicType__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
lldb::BasicType result;
SWIG_check_num_args("lldb::SBType::GetBasicType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetBasicType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetBasicType",1,SWIGTYPE_p_lldb__SBType);
}
result = (lldb::BasicType)(arg1)->GetBasicType();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetBasicType__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
lldb::BasicType arg2 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBType::GetBasicType",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetBasicType",1,"lldb::SBType *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBType::GetBasicType",2,"lldb::BasicType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetBasicType",1,SWIGTYPE_p_lldb__SBType);
}
arg2 = (lldb::BasicType)lua_tointeger(L, 2);
result = (arg1)->GetBasicType(arg2);
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetBasicType(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBType, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBType_GetBasicType__SWIG_0(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBType, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBType_GetBasicType__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBType_GetBasicType'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBType::GetBasicType()\n"
" lldb::SBType::GetBasicType(lldb::BasicType)\n");
lua_error(L);return 0;
}
static int _wrap_SBType_GetNumberOfFields(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBType::GetNumberOfFields",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetNumberOfFields",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetNumberOfFields",1,SWIGTYPE_p_lldb__SBType);
}
result = (uint32_t)(arg1)->GetNumberOfFields();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetNumberOfDirectBaseClasses(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBType::GetNumberOfDirectBaseClasses",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetNumberOfDirectBaseClasses",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetNumberOfDirectBaseClasses",1,SWIGTYPE_p_lldb__SBType);
}
result = (uint32_t)(arg1)->GetNumberOfDirectBaseClasses();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetNumberOfVirtualBaseClasses(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBType::GetNumberOfVirtualBaseClasses",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetNumberOfVirtualBaseClasses",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetNumberOfVirtualBaseClasses",1,SWIGTYPE_p_lldb__SBType);
}
result = (uint32_t)(arg1)->GetNumberOfVirtualBaseClasses();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetFieldAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
uint32_t arg2 ;
lldb::SBTypeMember result;
SWIG_check_num_args("lldb::SBType::GetFieldAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetFieldAtIndex",1,"lldb::SBType *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBType::GetFieldAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetFieldAtIndex",1,SWIGTYPE_p_lldb__SBType);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetFieldAtIndex(arg2);
{
lldb::SBTypeMember * resultptr = new lldb::SBTypeMember((const lldb::SBTypeMember &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeMember,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetDirectBaseClassAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
uint32_t arg2 ;
lldb::SBTypeMember result;
SWIG_check_num_args("lldb::SBType::GetDirectBaseClassAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetDirectBaseClassAtIndex",1,"lldb::SBType *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBType::GetDirectBaseClassAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetDirectBaseClassAtIndex",1,SWIGTYPE_p_lldb__SBType);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetDirectBaseClassAtIndex(arg2);
{
lldb::SBTypeMember * resultptr = new lldb::SBTypeMember((const lldb::SBTypeMember &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeMember,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetVirtualBaseClassAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
uint32_t arg2 ;
lldb::SBTypeMember result;
SWIG_check_num_args("lldb::SBType::GetVirtualBaseClassAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetVirtualBaseClassAtIndex",1,"lldb::SBType *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBType::GetVirtualBaseClassAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetVirtualBaseClassAtIndex",1,SWIGTYPE_p_lldb__SBType);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetVirtualBaseClassAtIndex(arg2);
{
lldb::SBTypeMember * resultptr = new lldb::SBTypeMember((const lldb::SBTypeMember &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeMember,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetEnumMembers(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
lldb::SBTypeEnumMemberList result;
SWIG_check_num_args("lldb::SBType::GetEnumMembers",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetEnumMembers",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetEnumMembers",1,SWIGTYPE_p_lldb__SBType);
}
result = (arg1)->GetEnumMembers();
{
lldb::SBTypeEnumMemberList * resultptr = new lldb::SBTypeEnumMemberList((const lldb::SBTypeEnumMemberList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeEnumMemberList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetModule(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
lldb::SBModule result;
SWIG_check_num_args("lldb::SBType::GetModule",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetModule",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetModule",1,SWIGTYPE_p_lldb__SBType);
}
result = (arg1)->GetModule();
{
lldb::SBModule * resultptr = new lldb::SBModule((const lldb::SBModule &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBType::GetName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetName",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetName",1,SWIGTYPE_p_lldb__SBType);
}
result = (char *)(arg1)->GetName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetDisplayTypeName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBType::GetDisplayTypeName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetDisplayTypeName",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetDisplayTypeName",1,SWIGTYPE_p_lldb__SBType);
}
result = (char *)(arg1)->GetDisplayTypeName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetTypeClass(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
lldb::TypeClass result;
SWIG_check_num_args("lldb::SBType::GetTypeClass",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetTypeClass",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetTypeClass",1,SWIGTYPE_p_lldb__SBType);
}
result = (lldb::TypeClass)(arg1)->GetTypeClass();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetNumberOfTemplateArguments(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBType::GetNumberOfTemplateArguments",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetNumberOfTemplateArguments",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetNumberOfTemplateArguments",1,SWIGTYPE_p_lldb__SBType);
}
result = (uint32_t)(arg1)->GetNumberOfTemplateArguments();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetTemplateArgumentType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
uint32_t arg2 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBType::GetTemplateArgumentType",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetTemplateArgumentType",1,"lldb::SBType *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBType::GetTemplateArgumentType",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetTemplateArgumentType",1,SWIGTYPE_p_lldb__SBType);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetTemplateArgumentType(arg2);
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetTemplateArgumentKind(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
uint32_t arg2 ;
lldb::TemplateArgumentKind result;
SWIG_check_num_args("lldb::SBType::GetTemplateArgumentKind",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetTemplateArgumentKind",1,"lldb::SBType *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBType::GetTemplateArgumentKind",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetTemplateArgumentKind",1,SWIGTYPE_p_lldb__SBType);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (lldb::TemplateArgumentKind)(arg1)->GetTemplateArgumentKind(arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetFunctionReturnType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBType::GetFunctionReturnType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetFunctionReturnType",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetFunctionReturnType",1,SWIGTYPE_p_lldb__SBType);
}
result = (arg1)->GetFunctionReturnType();
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetFunctionArgumentTypes(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
lldb::SBTypeList result;
SWIG_check_num_args("lldb::SBType::GetFunctionArgumentTypes",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetFunctionArgumentTypes",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetFunctionArgumentTypes",1,SWIGTYPE_p_lldb__SBType);
}
result = (arg1)->GetFunctionArgumentTypes();
{
lldb::SBTypeList * resultptr = new lldb::SBTypeList((const lldb::SBTypeList &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeList,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetNumberOfMemberFunctions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBType::GetNumberOfMemberFunctions",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetNumberOfMemberFunctions",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetNumberOfMemberFunctions",1,SWIGTYPE_p_lldb__SBType);
}
result = (uint32_t)(arg1)->GetNumberOfMemberFunctions();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetMemberFunctionAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
uint32_t arg2 ;
lldb::SBTypeMemberFunction result;
SWIG_check_num_args("lldb::SBType::GetMemberFunctionAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetMemberFunctionAtIndex",1,"lldb::SBType *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBType::GetMemberFunctionAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetMemberFunctionAtIndex",1,SWIGTYPE_p_lldb__SBType);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetMemberFunctionAtIndex(arg2);
{
lldb::SBTypeMemberFunction * resultptr = new lldb::SBTypeMemberFunction((const lldb::SBTypeMemberFunction &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeMemberFunction,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_IsTypeComplete(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBType::IsTypeComplete",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsTypeComplete",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_IsTypeComplete",1,SWIGTYPE_p_lldb__SBType);
}
result = (bool)(arg1)->IsTypeComplete();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType_GetTypeFlags(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBType::GetTypeFlags",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetTypeFlags",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType_GetTypeFlags",1,SWIGTYPE_p_lldb__SBType);
}
result = (uint32_t)(arg1)->GetTypeFlags();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
lldb::SBType *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBType::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::operator ==",1,"lldb::SBType *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBType::operator ==",2,"lldb::SBType &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType___eq",1,SWIGTYPE_p_lldb__SBType);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType___eq",2,SWIGTYPE_p_lldb__SBType);
}
result = (bool)(arg1)->operator ==(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBType___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType *arg1 = (lldb::SBType *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBType::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::__str__",1,"lldb::SBType *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBType___tostring",1,SWIGTYPE_p_lldb__SBType);
}
result = lldb_SBType___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBType(void *obj) {
lldb::SBType *arg1 = (lldb::SBType *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBType(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBType);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBType_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBType_methods[]= {
{ "IsValid", _wrap_SBType_IsValid},
{ "GetByteSize", _wrap_SBType_GetByteSize},
{ "IsPointerType", _wrap_SBType_IsPointerType},
{ "IsReferenceType", _wrap_SBType_IsReferenceType},
{ "IsFunctionType", _wrap_SBType_IsFunctionType},
{ "IsPolymorphicClass", _wrap_SBType_IsPolymorphicClass},
{ "IsArrayType", _wrap_SBType_IsArrayType},
{ "IsVectorType", _wrap_SBType_IsVectorType},
{ "IsTypedefType", _wrap_SBType_IsTypedefType},
{ "IsAnonymousType", _wrap_SBType_IsAnonymousType},
{ "IsScopedEnumerationType", _wrap_SBType_IsScopedEnumerationType},
{ "GetPointerType", _wrap_SBType_GetPointerType},
{ "GetPointeeType", _wrap_SBType_GetPointeeType},
{ "GetReferenceType", _wrap_SBType_GetReferenceType},
{ "GetTypedefedType", _wrap_SBType_GetTypedefedType},
{ "GetDereferencedType", _wrap_SBType_GetDereferencedType},
{ "GetUnqualifiedType", _wrap_SBType_GetUnqualifiedType},
{ "GetCanonicalType", _wrap_SBType_GetCanonicalType},
{ "GetEnumerationIntegerType", _wrap_SBType_GetEnumerationIntegerType},
{ "GetArrayElementType", _wrap_SBType_GetArrayElementType},
{ "GetArrayType", _wrap_SBType_GetArrayType},
{ "GetVectorElementType", _wrap_SBType_GetVectorElementType},
{ "GetBasicType", _wrap_SBType_GetBasicType},
{ "GetNumberOfFields", _wrap_SBType_GetNumberOfFields},
{ "GetNumberOfDirectBaseClasses", _wrap_SBType_GetNumberOfDirectBaseClasses},
{ "GetNumberOfVirtualBaseClasses", _wrap_SBType_GetNumberOfVirtualBaseClasses},
{ "GetFieldAtIndex", _wrap_SBType_GetFieldAtIndex},
{ "GetDirectBaseClassAtIndex", _wrap_SBType_GetDirectBaseClassAtIndex},
{ "GetVirtualBaseClassAtIndex", _wrap_SBType_GetVirtualBaseClassAtIndex},
{ "GetEnumMembers", _wrap_SBType_GetEnumMembers},
{ "GetModule", _wrap_SBType_GetModule},
{ "GetName", _wrap_SBType_GetName},
{ "GetDisplayTypeName", _wrap_SBType_GetDisplayTypeName},
{ "GetTypeClass", _wrap_SBType_GetTypeClass},
{ "GetNumberOfTemplateArguments", _wrap_SBType_GetNumberOfTemplateArguments},
{ "GetTemplateArgumentType", _wrap_SBType_GetTemplateArgumentType},
{ "GetTemplateArgumentKind", _wrap_SBType_GetTemplateArgumentKind},
{ "GetFunctionReturnType", _wrap_SBType_GetFunctionReturnType},
{ "GetFunctionArgumentTypes", _wrap_SBType_GetFunctionArgumentTypes},
{ "GetNumberOfMemberFunctions", _wrap_SBType_GetNumberOfMemberFunctions},
{ "GetMemberFunctionAtIndex", _wrap_SBType_GetMemberFunctionAtIndex},
{ "IsTypeComplete", _wrap_SBType_IsTypeComplete},
{ "GetTypeFlags", _wrap_SBType_GetTypeFlags},
{ "__eq", _wrap_SBType___eq},
{ "__tostring", _wrap_SBType___tostring},
{0,0}
};
static swig_lua_method swig_SBType_meta[] = {
{ "__eq", _wrap_SBType___eq},
{ "__tostring", _wrap_SBType___tostring},
{0,0}
};
static swig_lua_attribute swig_SBType_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBType_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBType_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBType_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBType_Sf_SwigStatic = {
"SBType",
swig_SBType_Sf_SwigStatic_methods,
swig_SBType_Sf_SwigStatic_attributes,
swig_SBType_Sf_SwigStatic_constants,
swig_SBType_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBType_bases[] = {0};
static const char *swig_SBType_base_names[] = {0};
static swig_lua_class _wrap_class_SBType = { "SBType", "SBType", &SWIGTYPE_p_lldb__SBType,_proxy__wrap_new_SBType, swig_delete_SBType, swig_SBType_methods, swig_SBType_attributes, &swig_SBType_Sf_SwigStatic, swig_SBType_meta, swig_SBType_bases, swig_SBType_base_names };
static int _wrap_new_SBTypeList(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeList *result = 0 ;
SWIG_check_num_args("lldb::SBTypeList::SBTypeList",0,0)
result = (lldb::SBTypeList *)new lldb::SBTypeList();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeList,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeList_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeList *arg1 = (lldb::SBTypeList *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeList::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeList::IsValid",1,"lldb::SBTypeList *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeList,0))){
SWIG_fail_ptr("SBTypeList_IsValid",1,SWIGTYPE_p_lldb__SBTypeList);
}
result = (bool)(arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeList_Append(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeList *arg1 = (lldb::SBTypeList *) 0 ;
lldb::SBType arg2 ;
lldb::SBType *argp2 ;
SWIG_check_num_args("lldb::SBTypeList::Append",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeList::Append",1,"lldb::SBTypeList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeList::Append",2,"lldb::SBType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeList,0))){
SWIG_fail_ptr("SBTypeList_Append",1,SWIGTYPE_p_lldb__SBTypeList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBTypeList_Append",2,SWIGTYPE_p_lldb__SBType);
}
arg2 = *argp2;
(arg1)->Append(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeList_GetTypeAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeList *arg1 = (lldb::SBTypeList *) 0 ;
uint32_t arg2 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBTypeList::GetTypeAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeList::GetTypeAtIndex",1,"lldb::SBTypeList *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeList::GetTypeAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeList,0))){
SWIG_fail_ptr("SBTypeList_GetTypeAtIndex",1,SWIGTYPE_p_lldb__SBTypeList);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetTypeAtIndex(arg2);
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeList_GetSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeList *arg1 = (lldb::SBTypeList *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTypeList::GetSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeList::GetSize",1,"lldb::SBTypeList *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeList,0))){
SWIG_fail_ptr("SBTypeList_GetSize",1,SWIGTYPE_p_lldb__SBTypeList);
}
result = (uint32_t)(arg1)->GetSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBTypeList(void *obj) {
lldb::SBTypeList *arg1 = (lldb::SBTypeList *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBTypeList(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBTypeList);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBTypeList_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBTypeList_methods[]= {
{ "IsValid", _wrap_SBTypeList_IsValid},
{ "Append", _wrap_SBTypeList_Append},
{ "GetTypeAtIndex", _wrap_SBTypeList_GetTypeAtIndex},
{ "GetSize", _wrap_SBTypeList_GetSize},
{0,0}
};
static swig_lua_method swig_SBTypeList_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBTypeList_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBTypeList_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBTypeList_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBTypeList_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBTypeList_Sf_SwigStatic = {
"SBTypeList",
swig_SBTypeList_Sf_SwigStatic_methods,
swig_SBTypeList_Sf_SwigStatic_attributes,
swig_SBTypeList_Sf_SwigStatic_constants,
swig_SBTypeList_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBTypeList_bases[] = {0};
static const char *swig_SBTypeList_base_names[] = {0};
static swig_lua_class _wrap_class_SBTypeList = { "SBTypeList", "SBTypeList", &SWIGTYPE_p_lldb__SBTypeList,_proxy__wrap_new_SBTypeList, swig_delete_SBTypeList, swig_SBTypeList_methods, swig_SBTypeList_attributes, &swig_SBTypeList_Sf_SwigStatic, swig_SBTypeList_meta, swig_SBTypeList_bases, swig_SBTypeList_base_names };
static int _wrap_new_SBTypeCategory__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *result = 0 ;
SWIG_check_num_args("lldb::SBTypeCategory::SBTypeCategory",0,0)
result = (lldb::SBTypeCategory *)new lldb::SBTypeCategory();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeCategory,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeCategory__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = 0 ;
lldb::SBTypeCategory *result = 0 ;
SWIG_check_num_args("lldb::SBTypeCategory::SBTypeCategory",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::SBTypeCategory",1,"lldb::SBTypeCategory const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("new_SBTypeCategory",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
result = (lldb::SBTypeCategory *)new lldb::SBTypeCategory((lldb::SBTypeCategory const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeCategory,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeCategory(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBTypeCategory__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeCategory, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBTypeCategory__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeCategory'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTypeCategory::SBTypeCategory()\n"
" lldb::SBTypeCategory::SBTypeCategory(lldb::SBTypeCategory const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTypeCategory_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeCategory::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::IsValid",1,"lldb::SBTypeCategory const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_IsValid",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
result = (bool)((lldb::SBTypeCategory const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetEnabled(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeCategory::GetEnabled",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetEnabled",1,"lldb::SBTypeCategory *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetEnabled",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
result = (bool)(arg1)->GetEnabled();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_SetEnabled(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBTypeCategory::SetEnabled",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::SetEnabled",1,"lldb::SBTypeCategory *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::SetEnabled",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_SetEnabled",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetEnabled(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBTypeCategory::GetName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetName",1,"lldb::SBTypeCategory *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetName",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
result = (char *)(arg1)->GetName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetLanguageAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
uint32_t arg2 ;
lldb::LanguageType result;
SWIG_check_num_args("lldb::SBTypeCategory::GetLanguageAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetLanguageAtIndex",1,"lldb::SBTypeCategory *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetLanguageAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetLanguageAtIndex",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (lldb::LanguageType)(arg1)->GetLanguageAtIndex(arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetNumLanguages(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTypeCategory::GetNumLanguages",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetNumLanguages",1,"lldb::SBTypeCategory *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetNumLanguages",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
result = (uint32_t)(arg1)->GetNumLanguages();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_AddLanguage(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
lldb::LanguageType arg2 ;
SWIG_check_num_args("lldb::SBTypeCategory::AddLanguage",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::AddLanguage",1,"lldb::SBTypeCategory *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::AddLanguage",2,"lldb::LanguageType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_AddLanguage",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
arg2 = (lldb::LanguageType)lua_tointeger(L, 2);
(arg1)->AddLanguage(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
lldb::SBStream *arg2 = 0 ;
lldb::DescriptionLevel arg3 ;
bool result;
SWIG_check_num_args("lldb::SBTypeCategory::GetDescription",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetDescription",1,"lldb::SBTypeCategory *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetDescription",2,"lldb::SBStream &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTypeCategory::GetDescription",3,"lldb::DescriptionLevel");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetDescription",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBTypeCategory_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3);
result = (bool)(arg1)->GetDescription(*arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetNumFormats(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTypeCategory::GetNumFormats",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetNumFormats",1,"lldb::SBTypeCategory *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetNumFormats",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
result = (uint32_t)(arg1)->GetNumFormats();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetNumSummaries(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTypeCategory::GetNumSummaries",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetNumSummaries",1,"lldb::SBTypeCategory *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetNumSummaries",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
result = (uint32_t)(arg1)->GetNumSummaries();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetNumFilters(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTypeCategory::GetNumFilters",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetNumFilters",1,"lldb::SBTypeCategory *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetNumFilters",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
result = (uint32_t)(arg1)->GetNumFilters();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetNumSynthetics(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTypeCategory::GetNumSynthetics",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetNumSynthetics",1,"lldb::SBTypeCategory *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetNumSynthetics",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
result = (uint32_t)(arg1)->GetNumSynthetics();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
uint32_t arg2 ;
lldb::SBTypeNameSpecifier result;
SWIG_check_num_args("lldb::SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex",1,"lldb::SBTypeCategory *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetTypeNameSpecifierForFilterAtIndex(arg2);
{
lldb::SBTypeNameSpecifier * resultptr = new lldb::SBTypeNameSpecifier((const lldb::SBTypeNameSpecifier &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
uint32_t arg2 ;
lldb::SBTypeNameSpecifier result;
SWIG_check_num_args("lldb::SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex",1,"lldb::SBTypeCategory *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetTypeNameSpecifierForFormatAtIndex(arg2);
{
lldb::SBTypeNameSpecifier * resultptr = new lldb::SBTypeNameSpecifier((const lldb::SBTypeNameSpecifier &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
uint32_t arg2 ;
lldb::SBTypeNameSpecifier result;
SWIG_check_num_args("lldb::SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex",1,"lldb::SBTypeCategory *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetTypeNameSpecifierForSummaryAtIndex(arg2);
{
lldb::SBTypeNameSpecifier * resultptr = new lldb::SBTypeNameSpecifier((const lldb::SBTypeNameSpecifier &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
uint32_t arg2 ;
lldb::SBTypeNameSpecifier result;
SWIG_check_num_args("lldb::SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex",1,"lldb::SBTypeCategory *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetTypeNameSpecifierForSyntheticAtIndex(arg2);
{
lldb::SBTypeNameSpecifier * resultptr = new lldb::SBTypeNameSpecifier((const lldb::SBTypeNameSpecifier &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetFilterForType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
lldb::SBTypeNameSpecifier arg2 ;
lldb::SBTypeNameSpecifier *argp2 ;
lldb::SBTypeFilter result;
SWIG_check_num_args("lldb::SBTypeCategory::GetFilterForType",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetFilterForType",1,"lldb::SBTypeCategory *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetFilterForType",2,"lldb::SBTypeNameSpecifier");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetFilterForType",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeCategory_GetFilterForType",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
arg2 = *argp2;
result = (arg1)->GetFilterForType(arg2);
{
lldb::SBTypeFilter * resultptr = new lldb::SBTypeFilter((const lldb::SBTypeFilter &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeFilter,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetFormatForType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
lldb::SBTypeNameSpecifier arg2 ;
lldb::SBTypeNameSpecifier *argp2 ;
lldb::SBTypeFormat result;
SWIG_check_num_args("lldb::SBTypeCategory::GetFormatForType",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetFormatForType",1,"lldb::SBTypeCategory *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetFormatForType",2,"lldb::SBTypeNameSpecifier");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetFormatForType",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeCategory_GetFormatForType",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
arg2 = *argp2;
result = (arg1)->GetFormatForType(arg2);
{
lldb::SBTypeFormat * resultptr = new lldb::SBTypeFormat((const lldb::SBTypeFormat &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetSummaryForType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
lldb::SBTypeNameSpecifier arg2 ;
lldb::SBTypeNameSpecifier *argp2 ;
lldb::SBTypeSummary result;
SWIG_check_num_args("lldb::SBTypeCategory::GetSummaryForType",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetSummaryForType",1,"lldb::SBTypeCategory *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetSummaryForType",2,"lldb::SBTypeNameSpecifier");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetSummaryForType",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeCategory_GetSummaryForType",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
arg2 = *argp2;
result = (arg1)->GetSummaryForType(arg2);
{
lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary((const lldb::SBTypeSummary &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetSyntheticForType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
lldb::SBTypeNameSpecifier arg2 ;
lldb::SBTypeNameSpecifier *argp2 ;
lldb::SBTypeSynthetic result;
SWIG_check_num_args("lldb::SBTypeCategory::GetSyntheticForType",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetSyntheticForType",1,"lldb::SBTypeCategory *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetSyntheticForType",2,"lldb::SBTypeNameSpecifier");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetSyntheticForType",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeCategory_GetSyntheticForType",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
arg2 = *argp2;
result = (arg1)->GetSyntheticForType(arg2);
{
lldb::SBTypeSynthetic * resultptr = new lldb::SBTypeSynthetic((const lldb::SBTypeSynthetic &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetFilterAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
uint32_t arg2 ;
lldb::SBTypeFilter result;
SWIG_check_num_args("lldb::SBTypeCategory::GetFilterAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetFilterAtIndex",1,"lldb::SBTypeCategory *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetFilterAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetFilterAtIndex",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetFilterAtIndex(arg2);
{
lldb::SBTypeFilter * resultptr = new lldb::SBTypeFilter((const lldb::SBTypeFilter &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeFilter,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetFormatAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
uint32_t arg2 ;
lldb::SBTypeFormat result;
SWIG_check_num_args("lldb::SBTypeCategory::GetFormatAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetFormatAtIndex",1,"lldb::SBTypeCategory *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetFormatAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetFormatAtIndex",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetFormatAtIndex(arg2);
{
lldb::SBTypeFormat * resultptr = new lldb::SBTypeFormat((const lldb::SBTypeFormat &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetSummaryAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
uint32_t arg2 ;
lldb::SBTypeSummary result;
SWIG_check_num_args("lldb::SBTypeCategory::GetSummaryAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetSummaryAtIndex",1,"lldb::SBTypeCategory *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetSummaryAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetSummaryAtIndex",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetSummaryAtIndex(arg2);
{
lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary((const lldb::SBTypeSummary &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_GetSyntheticAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
uint32_t arg2 ;
lldb::SBTypeSynthetic result;
SWIG_check_num_args("lldb::SBTypeCategory::GetSyntheticAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetSyntheticAtIndex",1,"lldb::SBTypeCategory *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetSyntheticAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_GetSyntheticAtIndex",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetSyntheticAtIndex(arg2);
{
lldb::SBTypeSynthetic * resultptr = new lldb::SBTypeSynthetic((const lldb::SBTypeSynthetic &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_AddTypeFormat(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
lldb::SBTypeNameSpecifier arg2 ;
lldb::SBTypeFormat arg3 ;
lldb::SBTypeNameSpecifier *argp2 ;
lldb::SBTypeFormat *argp3 ;
bool result;
SWIG_check_num_args("lldb::SBTypeCategory::AddTypeFormat",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeFormat",1,"lldb::SBTypeCategory *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeFormat",2,"lldb::SBTypeNameSpecifier");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeFormat",3,"lldb::SBTypeFormat");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_AddTypeFormat",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeCategory_AddTypeFormat",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
arg2 = *argp2;
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_lldb__SBTypeFormat,0))){
SWIG_fail_ptr("SBTypeCategory_AddTypeFormat",3,SWIGTYPE_p_lldb__SBTypeFormat);
}
arg3 = *argp3;
result = (bool)(arg1)->AddTypeFormat(arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_DeleteTypeFormat(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
lldb::SBTypeNameSpecifier arg2 ;
lldb::SBTypeNameSpecifier *argp2 ;
bool result;
SWIG_check_num_args("lldb::SBTypeCategory::DeleteTypeFormat",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::DeleteTypeFormat",1,"lldb::SBTypeCategory *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::DeleteTypeFormat",2,"lldb::SBTypeNameSpecifier");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_DeleteTypeFormat",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeCategory_DeleteTypeFormat",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
arg2 = *argp2;
result = (bool)(arg1)->DeleteTypeFormat(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_AddTypeSummary(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
lldb::SBTypeNameSpecifier arg2 ;
lldb::SBTypeSummary arg3 ;
lldb::SBTypeNameSpecifier *argp2 ;
lldb::SBTypeSummary *argp3 ;
bool result;
SWIG_check_num_args("lldb::SBTypeCategory::AddTypeSummary",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeSummary",1,"lldb::SBTypeCategory *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeSummary",2,"lldb::SBTypeNameSpecifier");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeSummary",3,"lldb::SBTypeSummary");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_AddTypeSummary",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeCategory_AddTypeSummary",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
arg2 = *argp2;
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_lldb__SBTypeSummary,0))){
SWIG_fail_ptr("SBTypeCategory_AddTypeSummary",3,SWIGTYPE_p_lldb__SBTypeSummary);
}
arg3 = *argp3;
result = (bool)(arg1)->AddTypeSummary(arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_DeleteTypeSummary(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
lldb::SBTypeNameSpecifier arg2 ;
lldb::SBTypeNameSpecifier *argp2 ;
bool result;
SWIG_check_num_args("lldb::SBTypeCategory::DeleteTypeSummary",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::DeleteTypeSummary",1,"lldb::SBTypeCategory *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::DeleteTypeSummary",2,"lldb::SBTypeNameSpecifier");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_DeleteTypeSummary",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeCategory_DeleteTypeSummary",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
arg2 = *argp2;
result = (bool)(arg1)->DeleteTypeSummary(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_AddTypeFilter(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
lldb::SBTypeNameSpecifier arg2 ;
lldb::SBTypeFilter arg3 ;
lldb::SBTypeNameSpecifier *argp2 ;
lldb::SBTypeFilter *argp3 ;
bool result;
SWIG_check_num_args("lldb::SBTypeCategory::AddTypeFilter",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeFilter",1,"lldb::SBTypeCategory *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeFilter",2,"lldb::SBTypeNameSpecifier");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeFilter",3,"lldb::SBTypeFilter");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_AddTypeFilter",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeCategory_AddTypeFilter",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
arg2 = *argp2;
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_lldb__SBTypeFilter,0))){
SWIG_fail_ptr("SBTypeCategory_AddTypeFilter",3,SWIGTYPE_p_lldb__SBTypeFilter);
}
arg3 = *argp3;
result = (bool)(arg1)->AddTypeFilter(arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_DeleteTypeFilter(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
lldb::SBTypeNameSpecifier arg2 ;
lldb::SBTypeNameSpecifier *argp2 ;
bool result;
SWIG_check_num_args("lldb::SBTypeCategory::DeleteTypeFilter",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::DeleteTypeFilter",1,"lldb::SBTypeCategory *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::DeleteTypeFilter",2,"lldb::SBTypeNameSpecifier");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_DeleteTypeFilter",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeCategory_DeleteTypeFilter",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
arg2 = *argp2;
result = (bool)(arg1)->DeleteTypeFilter(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_AddTypeSynthetic(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
lldb::SBTypeNameSpecifier arg2 ;
lldb::SBTypeSynthetic arg3 ;
lldb::SBTypeNameSpecifier *argp2 ;
lldb::SBTypeSynthetic *argp3 ;
bool result;
SWIG_check_num_args("lldb::SBTypeCategory::AddTypeSynthetic",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeSynthetic",1,"lldb::SBTypeCategory *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeSynthetic",2,"lldb::SBTypeNameSpecifier");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeSynthetic",3,"lldb::SBTypeSynthetic");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_AddTypeSynthetic",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeCategory_AddTypeSynthetic",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
arg2 = *argp2;
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){
SWIG_fail_ptr("SBTypeCategory_AddTypeSynthetic",3,SWIGTYPE_p_lldb__SBTypeSynthetic);
}
arg3 = *argp3;
result = (bool)(arg1)->AddTypeSynthetic(arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory_DeleteTypeSynthetic(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
lldb::SBTypeNameSpecifier arg2 ;
lldb::SBTypeNameSpecifier *argp2 ;
bool result;
SWIG_check_num_args("lldb::SBTypeCategory::DeleteTypeSynthetic",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::DeleteTypeSynthetic",1,"lldb::SBTypeCategory *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::DeleteTypeSynthetic",2,"lldb::SBTypeNameSpecifier");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory_DeleteTypeSynthetic",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeCategory_DeleteTypeSynthetic",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
arg2 = *argp2;
result = (bool)(arg1)->DeleteTypeSynthetic(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeCategory___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBTypeCategory::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::__str__",1,"lldb::SBTypeCategory *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){
SWIG_fail_ptr("SBTypeCategory___tostring",1,SWIGTYPE_p_lldb__SBTypeCategory);
}
result = lldb_SBTypeCategory___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBTypeCategory(void *obj) {
lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBTypeCategory(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBTypeCategory);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBTypeCategory_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBTypeCategory_methods[]= {
{ "IsValid", _wrap_SBTypeCategory_IsValid},
{ "GetEnabled", _wrap_SBTypeCategory_GetEnabled},
{ "SetEnabled", _wrap_SBTypeCategory_SetEnabled},
{ "GetName", _wrap_SBTypeCategory_GetName},
{ "GetLanguageAtIndex", _wrap_SBTypeCategory_GetLanguageAtIndex},
{ "GetNumLanguages", _wrap_SBTypeCategory_GetNumLanguages},
{ "AddLanguage", _wrap_SBTypeCategory_AddLanguage},
{ "GetDescription", _wrap_SBTypeCategory_GetDescription},
{ "GetNumFormats", _wrap_SBTypeCategory_GetNumFormats},
{ "GetNumSummaries", _wrap_SBTypeCategory_GetNumSummaries},
{ "GetNumFilters", _wrap_SBTypeCategory_GetNumFilters},
{ "GetNumSynthetics", _wrap_SBTypeCategory_GetNumSynthetics},
{ "GetTypeNameSpecifierForFilterAtIndex", _wrap_SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex},
{ "GetTypeNameSpecifierForFormatAtIndex", _wrap_SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex},
{ "GetTypeNameSpecifierForSummaryAtIndex", _wrap_SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex},
{ "GetTypeNameSpecifierForSyntheticAtIndex", _wrap_SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex},
{ "GetFilterForType", _wrap_SBTypeCategory_GetFilterForType},
{ "GetFormatForType", _wrap_SBTypeCategory_GetFormatForType},
{ "GetSummaryForType", _wrap_SBTypeCategory_GetSummaryForType},
{ "GetSyntheticForType", _wrap_SBTypeCategory_GetSyntheticForType},
{ "GetFilterAtIndex", _wrap_SBTypeCategory_GetFilterAtIndex},
{ "GetFormatAtIndex", _wrap_SBTypeCategory_GetFormatAtIndex},
{ "GetSummaryAtIndex", _wrap_SBTypeCategory_GetSummaryAtIndex},
{ "GetSyntheticAtIndex", _wrap_SBTypeCategory_GetSyntheticAtIndex},
{ "AddTypeFormat", _wrap_SBTypeCategory_AddTypeFormat},
{ "DeleteTypeFormat", _wrap_SBTypeCategory_DeleteTypeFormat},
{ "AddTypeSummary", _wrap_SBTypeCategory_AddTypeSummary},
{ "DeleteTypeSummary", _wrap_SBTypeCategory_DeleteTypeSummary},
{ "AddTypeFilter", _wrap_SBTypeCategory_AddTypeFilter},
{ "DeleteTypeFilter", _wrap_SBTypeCategory_DeleteTypeFilter},
{ "AddTypeSynthetic", _wrap_SBTypeCategory_AddTypeSynthetic},
{ "DeleteTypeSynthetic", _wrap_SBTypeCategory_DeleteTypeSynthetic},
{ "__tostring", _wrap_SBTypeCategory___tostring},
{0,0}
};
static swig_lua_method swig_SBTypeCategory_meta[] = {
{ "__tostring", _wrap_SBTypeCategory___tostring},
{0,0}
};
static swig_lua_attribute swig_SBTypeCategory_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBTypeCategory_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBTypeCategory_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBTypeCategory_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBTypeCategory_Sf_SwigStatic = {
"SBTypeCategory",
swig_SBTypeCategory_Sf_SwigStatic_methods,
swig_SBTypeCategory_Sf_SwigStatic_attributes,
swig_SBTypeCategory_Sf_SwigStatic_constants,
swig_SBTypeCategory_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBTypeCategory_bases[] = {0};
static const char *swig_SBTypeCategory_base_names[] = {0};
static swig_lua_class _wrap_class_SBTypeCategory = { "SBTypeCategory", "SBTypeCategory", &SWIGTYPE_p_lldb__SBTypeCategory,_proxy__wrap_new_SBTypeCategory, swig_delete_SBTypeCategory, swig_SBTypeCategory_methods, swig_SBTypeCategory_attributes, &swig_SBTypeCategory_Sf_SwigStatic, swig_SBTypeCategory_meta, swig_SBTypeCategory_bases, swig_SBTypeCategory_base_names };
static int _wrap_new_SBTypeEnumMember__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeEnumMember *result = 0 ;
SWIG_check_num_args("lldb::SBTypeEnumMember::SBTypeEnumMember",0,0)
result = (lldb::SBTypeEnumMember *)new lldb::SBTypeEnumMember();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeEnumMember,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeEnumMember__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeEnumMember *arg1 = 0 ;
lldb::SBTypeEnumMember *result = 0 ;
SWIG_check_num_args("lldb::SBTypeEnumMember::SBTypeEnumMember",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMember::SBTypeEnumMember",1,"lldb::SBTypeEnumMember const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMember,0))){
SWIG_fail_ptr("new_SBTypeEnumMember",1,SWIGTYPE_p_lldb__SBTypeEnumMember);
}
result = (lldb::SBTypeEnumMember *)new lldb::SBTypeEnumMember((lldb::SBTypeEnumMember const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeEnumMember,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeEnumMember(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBTypeEnumMember__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeEnumMember, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBTypeEnumMember__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeEnumMember'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTypeEnumMember::SBTypeEnumMember()\n"
" lldb::SBTypeEnumMember::SBTypeEnumMember(lldb::SBTypeEnumMember const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTypeEnumMember_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeEnumMember::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMember::IsValid",1,"lldb::SBTypeEnumMember const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMember,0))){
SWIG_fail_ptr("SBTypeEnumMember_IsValid",1,SWIGTYPE_p_lldb__SBTypeEnumMember);
}
result = (bool)((lldb::SBTypeEnumMember const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeEnumMember_GetValueAsSigned(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ;
int64_t result;
SWIG_check_num_args("lldb::SBTypeEnumMember::GetValueAsSigned",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMember::GetValueAsSigned",1,"lldb::SBTypeEnumMember *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMember,0))){
SWIG_fail_ptr("SBTypeEnumMember_GetValueAsSigned",1,SWIGTYPE_p_lldb__SBTypeEnumMember);
}
result = (int64_t)(arg1)->GetValueAsSigned();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeEnumMember_GetValueAsUnsigned(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ;
uint64_t result;
SWIG_check_num_args("lldb::SBTypeEnumMember::GetValueAsUnsigned",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMember::GetValueAsUnsigned",1,"lldb::SBTypeEnumMember *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMember,0))){
SWIG_fail_ptr("SBTypeEnumMember_GetValueAsUnsigned",1,SWIGTYPE_p_lldb__SBTypeEnumMember);
}
result = (uint64_t)(arg1)->GetValueAsUnsigned();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeEnumMember_GetName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBTypeEnumMember::GetName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMember::GetName",1,"lldb::SBTypeEnumMember *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMember,0))){
SWIG_fail_ptr("SBTypeEnumMember_GetName",1,SWIGTYPE_p_lldb__SBTypeEnumMember);
}
result = (char *)(arg1)->GetName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeEnumMember_GetType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBTypeEnumMember::GetType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMember::GetType",1,"lldb::SBTypeEnumMember *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMember,0))){
SWIG_fail_ptr("SBTypeEnumMember_GetType",1,SWIGTYPE_p_lldb__SBTypeEnumMember);
}
result = (arg1)->GetType();
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeEnumMember_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ;
lldb::SBStream *arg2 = 0 ;
lldb::DescriptionLevel arg3 ;
bool result;
SWIG_check_num_args("lldb::SBTypeEnumMember::GetDescription",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMember::GetDescription",1,"lldb::SBTypeEnumMember *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeEnumMember::GetDescription",2,"lldb::SBStream &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTypeEnumMember::GetDescription",3,"lldb::DescriptionLevel");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMember,0))){
SWIG_fail_ptr("SBTypeEnumMember_GetDescription",1,SWIGTYPE_p_lldb__SBTypeEnumMember);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBTypeEnumMember_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3);
result = (bool)(arg1)->GetDescription(*arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeEnumMember___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBTypeEnumMember::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMember::__str__",1,"lldb::SBTypeEnumMember *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMember,0))){
SWIG_fail_ptr("SBTypeEnumMember___tostring",1,SWIGTYPE_p_lldb__SBTypeEnumMember);
}
result = lldb_SBTypeEnumMember___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBTypeEnumMember(void *obj) {
lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBTypeEnumMember(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBTypeEnumMember);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBTypeEnumMember_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBTypeEnumMember_methods[]= {
{ "IsValid", _wrap_SBTypeEnumMember_IsValid},
{ "GetValueAsSigned", _wrap_SBTypeEnumMember_GetValueAsSigned},
{ "GetValueAsUnsigned", _wrap_SBTypeEnumMember_GetValueAsUnsigned},
{ "GetName", _wrap_SBTypeEnumMember_GetName},
{ "GetType", _wrap_SBTypeEnumMember_GetType},
{ "GetDescription", _wrap_SBTypeEnumMember_GetDescription},
{ "__tostring", _wrap_SBTypeEnumMember___tostring},
{0,0}
};
static swig_lua_method swig_SBTypeEnumMember_meta[] = {
{ "__tostring", _wrap_SBTypeEnumMember___tostring},
{0,0}
};
static swig_lua_attribute swig_SBTypeEnumMember_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBTypeEnumMember_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBTypeEnumMember_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBTypeEnumMember_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBTypeEnumMember_Sf_SwigStatic = {
"SBTypeEnumMember",
swig_SBTypeEnumMember_Sf_SwigStatic_methods,
swig_SBTypeEnumMember_Sf_SwigStatic_attributes,
swig_SBTypeEnumMember_Sf_SwigStatic_constants,
swig_SBTypeEnumMember_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBTypeEnumMember_bases[] = {0};
static const char *swig_SBTypeEnumMember_base_names[] = {0};
static swig_lua_class _wrap_class_SBTypeEnumMember = { "SBTypeEnumMember", "SBTypeEnumMember", &SWIGTYPE_p_lldb__SBTypeEnumMember,_proxy__wrap_new_SBTypeEnumMember, swig_delete_SBTypeEnumMember, swig_SBTypeEnumMember_methods, swig_SBTypeEnumMember_attributes, &swig_SBTypeEnumMember_Sf_SwigStatic, swig_SBTypeEnumMember_meta, swig_SBTypeEnumMember_bases, swig_SBTypeEnumMember_base_names };
static int _wrap_new_SBTypeEnumMemberList__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeEnumMemberList *result = 0 ;
SWIG_check_num_args("lldb::SBTypeEnumMemberList::SBTypeEnumMemberList",0,0)
result = (lldb::SBTypeEnumMemberList *)new lldb::SBTypeEnumMemberList();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeEnumMemberList,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeEnumMemberList__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeEnumMemberList *arg1 = 0 ;
lldb::SBTypeEnumMemberList *result = 0 ;
SWIG_check_num_args("lldb::SBTypeEnumMemberList::SBTypeEnumMemberList",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMemberList::SBTypeEnumMemberList",1,"lldb::SBTypeEnumMemberList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMemberList,0))){
SWIG_fail_ptr("new_SBTypeEnumMemberList",1,SWIGTYPE_p_lldb__SBTypeEnumMemberList);
}
result = (lldb::SBTypeEnumMemberList *)new lldb::SBTypeEnumMemberList((lldb::SBTypeEnumMemberList const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeEnumMemberList,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeEnumMemberList(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBTypeEnumMemberList__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeEnumMemberList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBTypeEnumMemberList__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeEnumMemberList'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTypeEnumMemberList::SBTypeEnumMemberList()\n"
" lldb::SBTypeEnumMemberList::SBTypeEnumMemberList(lldb::SBTypeEnumMemberList const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTypeEnumMemberList_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeEnumMemberList *arg1 = (lldb::SBTypeEnumMemberList *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeEnumMemberList::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMemberList::IsValid",1,"lldb::SBTypeEnumMemberList *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMemberList,0))){
SWIG_fail_ptr("SBTypeEnumMemberList_IsValid",1,SWIGTYPE_p_lldb__SBTypeEnumMemberList);
}
result = (bool)(arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeEnumMemberList_Append(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeEnumMemberList *arg1 = (lldb::SBTypeEnumMemberList *) 0 ;
lldb::SBTypeEnumMember arg2 ;
lldb::SBTypeEnumMember *argp2 ;
SWIG_check_num_args("lldb::SBTypeEnumMemberList::Append",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMemberList::Append",1,"lldb::SBTypeEnumMemberList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeEnumMemberList::Append",2,"lldb::SBTypeEnumMember");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMemberList,0))){
SWIG_fail_ptr("SBTypeEnumMemberList_Append",1,SWIGTYPE_p_lldb__SBTypeEnumMemberList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeEnumMember,0))){
SWIG_fail_ptr("SBTypeEnumMemberList_Append",2,SWIGTYPE_p_lldb__SBTypeEnumMember);
}
arg2 = *argp2;
(arg1)->Append(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeEnumMemberList_GetTypeEnumMemberAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeEnumMemberList *arg1 = (lldb::SBTypeEnumMemberList *) 0 ;
uint32_t arg2 ;
lldb::SBTypeEnumMember result;
SWIG_check_num_args("lldb::SBTypeEnumMemberList::GetTypeEnumMemberAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMemberList::GetTypeEnumMemberAtIndex",1,"lldb::SBTypeEnumMemberList *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeEnumMemberList::GetTypeEnumMemberAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMemberList,0))){
SWIG_fail_ptr("SBTypeEnumMemberList_GetTypeEnumMemberAtIndex",1,SWIGTYPE_p_lldb__SBTypeEnumMemberList);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetTypeEnumMemberAtIndex(arg2);
{
lldb::SBTypeEnumMember * resultptr = new lldb::SBTypeEnumMember((const lldb::SBTypeEnumMember &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeEnumMember,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeEnumMemberList_GetSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeEnumMemberList *arg1 = (lldb::SBTypeEnumMemberList *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTypeEnumMemberList::GetSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMemberList::GetSize",1,"lldb::SBTypeEnumMemberList *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMemberList,0))){
SWIG_fail_ptr("SBTypeEnumMemberList_GetSize",1,SWIGTYPE_p_lldb__SBTypeEnumMemberList);
}
result = (uint32_t)(arg1)->GetSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBTypeEnumMemberList(void *obj) {
lldb::SBTypeEnumMemberList *arg1 = (lldb::SBTypeEnumMemberList *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBTypeEnumMemberList(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBTypeEnumMemberList);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBTypeEnumMemberList_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBTypeEnumMemberList_methods[]= {
{ "IsValid", _wrap_SBTypeEnumMemberList_IsValid},
{ "Append", _wrap_SBTypeEnumMemberList_Append},
{ "GetTypeEnumMemberAtIndex", _wrap_SBTypeEnumMemberList_GetTypeEnumMemberAtIndex},
{ "GetSize", _wrap_SBTypeEnumMemberList_GetSize},
{0,0}
};
static swig_lua_method swig_SBTypeEnumMemberList_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBTypeEnumMemberList_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBTypeEnumMemberList_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBTypeEnumMemberList_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBTypeEnumMemberList_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBTypeEnumMemberList_Sf_SwigStatic = {
"SBTypeEnumMemberList",
swig_SBTypeEnumMemberList_Sf_SwigStatic_methods,
swig_SBTypeEnumMemberList_Sf_SwigStatic_attributes,
swig_SBTypeEnumMemberList_Sf_SwigStatic_constants,
swig_SBTypeEnumMemberList_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBTypeEnumMemberList_bases[] = {0};
static const char *swig_SBTypeEnumMemberList_base_names[] = {0};
static swig_lua_class _wrap_class_SBTypeEnumMemberList = { "SBTypeEnumMemberList", "SBTypeEnumMemberList", &SWIGTYPE_p_lldb__SBTypeEnumMemberList,_proxy__wrap_new_SBTypeEnumMemberList, swig_delete_SBTypeEnumMemberList, swig_SBTypeEnumMemberList_methods, swig_SBTypeEnumMemberList_attributes, &swig_SBTypeEnumMemberList_Sf_SwigStatic, swig_SBTypeEnumMemberList_meta, swig_SBTypeEnumMemberList_bases, swig_SBTypeEnumMemberList_base_names };
static int _wrap_new_SBTypeFilter__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFilter *result = 0 ;
SWIG_check_num_args("lldb::SBTypeFilter::SBTypeFilter",0,0)
result = (lldb::SBTypeFilter *)new lldb::SBTypeFilter();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeFilter,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeFilter__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
uint32_t arg1 ;
lldb::SBTypeFilter *result = 0 ;
SWIG_check_num_args("lldb::SBTypeFilter::SBTypeFilter",1,1)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::SBTypeFilter",1,"uint32_t");
arg1 = (uint32_t)lua_tointeger(L, 1);
result = (lldb::SBTypeFilter *)new lldb::SBTypeFilter(arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeFilter,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeFilter__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFilter *arg1 = 0 ;
lldb::SBTypeFilter *result = 0 ;
SWIG_check_num_args("lldb::SBTypeFilter::SBTypeFilter",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::SBTypeFilter",1,"lldb::SBTypeFilter const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){
SWIG_fail_ptr("new_SBTypeFilter",1,SWIGTYPE_p_lldb__SBTypeFilter);
}
result = (lldb::SBTypeFilter *)new lldb::SBTypeFilter((lldb::SBTypeFilter const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeFilter,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeFilter(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBTypeFilter__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeFilter, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBTypeFilter__SWIG_2(L);
}
}
if (argc == 1) {
int _v;
{
_v = lua_isnumber(L,argv[0]);
}
if (_v) {
return _wrap_new_SBTypeFilter__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeFilter'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTypeFilter::SBTypeFilter()\n"
" lldb::SBTypeFilter::SBTypeFilter(uint32_t)\n"
" lldb::SBTypeFilter::SBTypeFilter(lldb::SBTypeFilter const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTypeFilter_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeFilter::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::IsValid",1,"lldb::SBTypeFilter const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){
SWIG_fail_ptr("SBTypeFilter_IsValid",1,SWIGTYPE_p_lldb__SBTypeFilter);
}
result = (bool)((lldb::SBTypeFilter const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFilter_IsEqualTo(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ;
lldb::SBTypeFilter *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeFilter::IsEqualTo",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::IsEqualTo",1,"lldb::SBTypeFilter *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeFilter::IsEqualTo",2,"lldb::SBTypeFilter &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){
SWIG_fail_ptr("SBTypeFilter_IsEqualTo",1,SWIGTYPE_p_lldb__SBTypeFilter);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeFilter,0))){
SWIG_fail_ptr("SBTypeFilter_IsEqualTo",2,SWIGTYPE_p_lldb__SBTypeFilter);
}
result = (bool)(arg1)->IsEqualTo(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFilter_GetNumberOfExpressionPaths(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTypeFilter::GetNumberOfExpressionPaths",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::GetNumberOfExpressionPaths",1,"lldb::SBTypeFilter *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){
SWIG_fail_ptr("SBTypeFilter_GetNumberOfExpressionPaths",1,SWIGTYPE_p_lldb__SBTypeFilter);
}
result = (uint32_t)(arg1)->GetNumberOfExpressionPaths();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFilter_GetExpressionPathAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ;
uint32_t arg2 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBTypeFilter::GetExpressionPathAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::GetExpressionPathAtIndex",1,"lldb::SBTypeFilter *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeFilter::GetExpressionPathAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){
SWIG_fail_ptr("SBTypeFilter_GetExpressionPathAtIndex",1,SWIGTYPE_p_lldb__SBTypeFilter);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (char *)(arg1)->GetExpressionPathAtIndex(arg2);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFilter_ReplaceExpressionPathAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ;
uint32_t arg2 ;
char *arg3 = (char *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeFilter::ReplaceExpressionPathAtIndex",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::ReplaceExpressionPathAtIndex",1,"lldb::SBTypeFilter *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeFilter::ReplaceExpressionPathAtIndex",2,"uint32_t");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTypeFilter::ReplaceExpressionPathAtIndex",3,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){
SWIG_fail_ptr("SBTypeFilter_ReplaceExpressionPathAtIndex",1,SWIGTYPE_p_lldb__SBTypeFilter);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
arg3 = (char *)lua_tostring(L, 3);
result = (bool)(arg1)->ReplaceExpressionPathAtIndex(arg2,(char const *)arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFilter_AppendExpressionPath(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBTypeFilter::AppendExpressionPath",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::AppendExpressionPath",1,"lldb::SBTypeFilter *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTypeFilter::AppendExpressionPath",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){
SWIG_fail_ptr("SBTypeFilter_AppendExpressionPath",1,SWIGTYPE_p_lldb__SBTypeFilter);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->AppendExpressionPath((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFilter_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ;
SWIG_check_num_args("lldb::SBTypeFilter::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::Clear",1,"lldb::SBTypeFilter *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){
SWIG_fail_ptr("SBTypeFilter_Clear",1,SWIGTYPE_p_lldb__SBTypeFilter);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFilter_GetOptions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTypeFilter::GetOptions",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::GetOptions",1,"lldb::SBTypeFilter *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){
SWIG_fail_ptr("SBTypeFilter_GetOptions",1,SWIGTYPE_p_lldb__SBTypeFilter);
}
result = (uint32_t)(arg1)->GetOptions();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFilter_SetOptions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBTypeFilter::SetOptions",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::SetOptions",1,"lldb::SBTypeFilter *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeFilter::SetOptions",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){
SWIG_fail_ptr("SBTypeFilter_SetOptions",1,SWIGTYPE_p_lldb__SBTypeFilter);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetOptions(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFilter_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ;
lldb::SBStream *arg2 = 0 ;
lldb::DescriptionLevel arg3 ;
bool result;
SWIG_check_num_args("lldb::SBTypeFilter::GetDescription",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::GetDescription",1,"lldb::SBTypeFilter *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeFilter::GetDescription",2,"lldb::SBStream &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTypeFilter::GetDescription",3,"lldb::DescriptionLevel");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){
SWIG_fail_ptr("SBTypeFilter_GetDescription",1,SWIGTYPE_p_lldb__SBTypeFilter);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBTypeFilter_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3);
result = (bool)(arg1)->GetDescription(*arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFilter___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ;
lldb::SBTypeFilter *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeFilter::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::operator ==",1,"lldb::SBTypeFilter *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeFilter::operator ==",2,"lldb::SBTypeFilter &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){
SWIG_fail_ptr("SBTypeFilter___eq",1,SWIGTYPE_p_lldb__SBTypeFilter);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeFilter,0))){
SWIG_fail_ptr("SBTypeFilter___eq",2,SWIGTYPE_p_lldb__SBTypeFilter);
}
result = (bool)(arg1)->operator ==(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFilter___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBTypeFilter::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::__str__",1,"lldb::SBTypeFilter *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){
SWIG_fail_ptr("SBTypeFilter___tostring",1,SWIGTYPE_p_lldb__SBTypeFilter);
}
result = lldb_SBTypeFilter___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBTypeFilter(void *obj) {
lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBTypeFilter(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBTypeFilter);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBTypeFilter_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBTypeFilter_methods[]= {
{ "IsValid", _wrap_SBTypeFilter_IsValid},
{ "IsEqualTo", _wrap_SBTypeFilter_IsEqualTo},
{ "GetNumberOfExpressionPaths", _wrap_SBTypeFilter_GetNumberOfExpressionPaths},
{ "GetExpressionPathAtIndex", _wrap_SBTypeFilter_GetExpressionPathAtIndex},
{ "ReplaceExpressionPathAtIndex", _wrap_SBTypeFilter_ReplaceExpressionPathAtIndex},
{ "AppendExpressionPath", _wrap_SBTypeFilter_AppendExpressionPath},
{ "Clear", _wrap_SBTypeFilter_Clear},
{ "GetOptions", _wrap_SBTypeFilter_GetOptions},
{ "SetOptions", _wrap_SBTypeFilter_SetOptions},
{ "GetDescription", _wrap_SBTypeFilter_GetDescription},
{ "__eq", _wrap_SBTypeFilter___eq},
{ "__tostring", _wrap_SBTypeFilter___tostring},
{0,0}
};
static swig_lua_method swig_SBTypeFilter_meta[] = {
{ "__eq", _wrap_SBTypeFilter___eq},
{ "__tostring", _wrap_SBTypeFilter___tostring},
{0,0}
};
static swig_lua_attribute swig_SBTypeFilter_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBTypeFilter_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBTypeFilter_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBTypeFilter_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBTypeFilter_Sf_SwigStatic = {
"SBTypeFilter",
swig_SBTypeFilter_Sf_SwigStatic_methods,
swig_SBTypeFilter_Sf_SwigStatic_attributes,
swig_SBTypeFilter_Sf_SwigStatic_constants,
swig_SBTypeFilter_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBTypeFilter_bases[] = {0};
static const char *swig_SBTypeFilter_base_names[] = {0};
static swig_lua_class _wrap_class_SBTypeFilter = { "SBTypeFilter", "SBTypeFilter", &SWIGTYPE_p_lldb__SBTypeFilter,_proxy__wrap_new_SBTypeFilter, swig_delete_SBTypeFilter, swig_SBTypeFilter_methods, swig_SBTypeFilter_attributes, &swig_SBTypeFilter_Sf_SwigStatic, swig_SBTypeFilter_meta, swig_SBTypeFilter_bases, swig_SBTypeFilter_base_names };
static int _wrap_new_SBTypeFormat__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFormat *result = 0 ;
SWIG_check_num_args("lldb::SBTypeFormat::SBTypeFormat",0,0)
result = (lldb::SBTypeFormat *)new lldb::SBTypeFormat();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeFormat__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::Format arg1 ;
uint32_t arg2 ;
lldb::SBTypeFormat *result = 0 ;
SWIG_check_num_args("lldb::SBTypeFormat::SBTypeFormat",2,2)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::SBTypeFormat",1,"lldb::Format");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeFormat::SBTypeFormat",2,"uint32_t");
arg1 = (lldb::Format)lua_tointeger(L, 1);
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (lldb::SBTypeFormat *)new lldb::SBTypeFormat(arg1,arg2);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeFormat__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::Format arg1 ;
lldb::SBTypeFormat *result = 0 ;
SWIG_check_num_args("lldb::SBTypeFormat::SBTypeFormat",1,1)
if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::SBTypeFormat",1,"lldb::Format");
arg1 = (lldb::Format)lua_tointeger(L, 1);
result = (lldb::SBTypeFormat *)new lldb::SBTypeFormat(arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeFormat__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
uint32_t arg2 ;
lldb::SBTypeFormat *result = 0 ;
SWIG_check_num_args("lldb::SBTypeFormat::SBTypeFormat",2,2)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::SBTypeFormat",1,"char const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeFormat::SBTypeFormat",2,"uint32_t");
arg1 = (char *)lua_tostring(L, 1);
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (lldb::SBTypeFormat *)new lldb::SBTypeFormat((char const *)arg1,arg2);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeFormat__SWIG_4(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
lldb::SBTypeFormat *result = 0 ;
SWIG_check_num_args("lldb::SBTypeFormat::SBTypeFormat",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::SBTypeFormat",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = (lldb::SBTypeFormat *)new lldb::SBTypeFormat((char const *)arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeFormat__SWIG_5(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFormat *arg1 = 0 ;
lldb::SBTypeFormat *result = 0 ;
SWIG_check_num_args("lldb::SBTypeFormat::SBTypeFormat",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::SBTypeFormat",1,"lldb::SBTypeFormat const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){
SWIG_fail_ptr("new_SBTypeFormat",1,SWIGTYPE_p_lldb__SBTypeFormat);
}
result = (lldb::SBTypeFormat *)new lldb::SBTypeFormat((lldb::SBTypeFormat const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeFormat(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBTypeFormat__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeFormat, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBTypeFormat__SWIG_5(L);
}
}
if (argc == 1) {
int _v;
{
_v = lua_isnumber(L,argv[0]);
}
if (_v) {
return _wrap_new_SBTypeFormat__SWIG_2(L);
}
}
if (argc == 1) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
return _wrap_new_SBTypeFormat__SWIG_4(L);
}
}
if (argc == 2) {
int _v;
{
_v = lua_isnumber(L,argv[0]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_new_SBTypeFormat__SWIG_1(L);
}
}
}
if (argc == 2) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_new_SBTypeFormat__SWIG_3(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeFormat'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTypeFormat::SBTypeFormat()\n"
" lldb::SBTypeFormat::SBTypeFormat(lldb::Format,uint32_t)\n"
" lldb::SBTypeFormat::SBTypeFormat(lldb::Format)\n"
" lldb::SBTypeFormat::SBTypeFormat(char const *,uint32_t)\n"
" lldb::SBTypeFormat::SBTypeFormat(char const *)\n"
" lldb::SBTypeFormat::SBTypeFormat(lldb::SBTypeFormat const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTypeFormat_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeFormat::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::IsValid",1,"lldb::SBTypeFormat const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){
SWIG_fail_ptr("SBTypeFormat_IsValid",1,SWIGTYPE_p_lldb__SBTypeFormat);
}
result = (bool)((lldb::SBTypeFormat const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFormat_IsEqualTo(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ;
lldb::SBTypeFormat *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeFormat::IsEqualTo",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::IsEqualTo",1,"lldb::SBTypeFormat *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeFormat::IsEqualTo",2,"lldb::SBTypeFormat &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){
SWIG_fail_ptr("SBTypeFormat_IsEqualTo",1,SWIGTYPE_p_lldb__SBTypeFormat);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeFormat,0))){
SWIG_fail_ptr("SBTypeFormat_IsEqualTo",2,SWIGTYPE_p_lldb__SBTypeFormat);
}
result = (bool)(arg1)->IsEqualTo(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFormat_GetFormat(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ;
lldb::Format result;
SWIG_check_num_args("lldb::SBTypeFormat::GetFormat",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::GetFormat",1,"lldb::SBTypeFormat *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){
SWIG_fail_ptr("SBTypeFormat_GetFormat",1,SWIGTYPE_p_lldb__SBTypeFormat);
}
result = (lldb::Format)(arg1)->GetFormat();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFormat_GetTypeName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBTypeFormat::GetTypeName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::GetTypeName",1,"lldb::SBTypeFormat *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){
SWIG_fail_ptr("SBTypeFormat_GetTypeName",1,SWIGTYPE_p_lldb__SBTypeFormat);
}
result = (char *)(arg1)->GetTypeName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFormat_GetOptions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTypeFormat::GetOptions",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::GetOptions",1,"lldb::SBTypeFormat *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){
SWIG_fail_ptr("SBTypeFormat_GetOptions",1,SWIGTYPE_p_lldb__SBTypeFormat);
}
result = (uint32_t)(arg1)->GetOptions();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFormat_SetFormat(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ;
lldb::Format arg2 ;
SWIG_check_num_args("lldb::SBTypeFormat::SetFormat",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::SetFormat",1,"lldb::SBTypeFormat *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeFormat::SetFormat",2,"lldb::Format");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){
SWIG_fail_ptr("SBTypeFormat_SetFormat",1,SWIGTYPE_p_lldb__SBTypeFormat);
}
arg2 = (lldb::Format)lua_tointeger(L, 2);
(arg1)->SetFormat(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFormat_SetTypeName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBTypeFormat::SetTypeName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::SetTypeName",1,"lldb::SBTypeFormat *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTypeFormat::SetTypeName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){
SWIG_fail_ptr("SBTypeFormat_SetTypeName",1,SWIGTYPE_p_lldb__SBTypeFormat);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetTypeName((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFormat_SetOptions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBTypeFormat::SetOptions",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::SetOptions",1,"lldb::SBTypeFormat *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeFormat::SetOptions",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){
SWIG_fail_ptr("SBTypeFormat_SetOptions",1,SWIGTYPE_p_lldb__SBTypeFormat);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetOptions(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFormat_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ;
lldb::SBStream *arg2 = 0 ;
lldb::DescriptionLevel arg3 ;
bool result;
SWIG_check_num_args("lldb::SBTypeFormat::GetDescription",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::GetDescription",1,"lldb::SBTypeFormat *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeFormat::GetDescription",2,"lldb::SBStream &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTypeFormat::GetDescription",3,"lldb::DescriptionLevel");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){
SWIG_fail_ptr("SBTypeFormat_GetDescription",1,SWIGTYPE_p_lldb__SBTypeFormat);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBTypeFormat_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3);
result = (bool)(arg1)->GetDescription(*arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFormat___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ;
lldb::SBTypeFormat *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeFormat::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::operator ==",1,"lldb::SBTypeFormat *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeFormat::operator ==",2,"lldb::SBTypeFormat &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){
SWIG_fail_ptr("SBTypeFormat___eq",1,SWIGTYPE_p_lldb__SBTypeFormat);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeFormat,0))){
SWIG_fail_ptr("SBTypeFormat___eq",2,SWIGTYPE_p_lldb__SBTypeFormat);
}
result = (bool)(arg1)->operator ==(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeFormat___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBTypeFormat::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::__str__",1,"lldb::SBTypeFormat *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){
SWIG_fail_ptr("SBTypeFormat___tostring",1,SWIGTYPE_p_lldb__SBTypeFormat);
}
result = lldb_SBTypeFormat___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBTypeFormat(void *obj) {
lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBTypeFormat(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBTypeFormat);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBTypeFormat_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBTypeFormat_methods[]= {
{ "IsValid", _wrap_SBTypeFormat_IsValid},
{ "IsEqualTo", _wrap_SBTypeFormat_IsEqualTo},
{ "GetFormat", _wrap_SBTypeFormat_GetFormat},
{ "GetTypeName", _wrap_SBTypeFormat_GetTypeName},
{ "GetOptions", _wrap_SBTypeFormat_GetOptions},
{ "SetFormat", _wrap_SBTypeFormat_SetFormat},
{ "SetTypeName", _wrap_SBTypeFormat_SetTypeName},
{ "SetOptions", _wrap_SBTypeFormat_SetOptions},
{ "GetDescription", _wrap_SBTypeFormat_GetDescription},
{ "__eq", _wrap_SBTypeFormat___eq},
{ "__tostring", _wrap_SBTypeFormat___tostring},
{0,0}
};
static swig_lua_method swig_SBTypeFormat_meta[] = {
{ "__eq", _wrap_SBTypeFormat___eq},
{ "__tostring", _wrap_SBTypeFormat___tostring},
{0,0}
};
static swig_lua_attribute swig_SBTypeFormat_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBTypeFormat_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBTypeFormat_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBTypeFormat_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBTypeFormat_Sf_SwigStatic = {
"SBTypeFormat",
swig_SBTypeFormat_Sf_SwigStatic_methods,
swig_SBTypeFormat_Sf_SwigStatic_attributes,
swig_SBTypeFormat_Sf_SwigStatic_constants,
swig_SBTypeFormat_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBTypeFormat_bases[] = {0};
static const char *swig_SBTypeFormat_base_names[] = {0};
static swig_lua_class _wrap_class_SBTypeFormat = { "SBTypeFormat", "SBTypeFormat", &SWIGTYPE_p_lldb__SBTypeFormat,_proxy__wrap_new_SBTypeFormat, swig_delete_SBTypeFormat, swig_SBTypeFormat_methods, swig_SBTypeFormat_attributes, &swig_SBTypeFormat_Sf_SwigStatic, swig_SBTypeFormat_meta, swig_SBTypeFormat_bases, swig_SBTypeFormat_base_names };
static int _wrap_new_SBTypeNameSpecifier__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeNameSpecifier *result = 0 ;
SWIG_check_num_args("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",0,0)
result = (lldb::SBTypeNameSpecifier *)new lldb::SBTypeNameSpecifier();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeNameSpecifier__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
bool arg2 ;
lldb::SBTypeNameSpecifier *result = 0 ;
SWIG_check_num_args("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",2,2)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",1,"char const *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",2,"bool");
arg1 = (char *)lua_tostring(L, 1);
arg2 = (lua_toboolean(L, 2)!=0);
result = (lldb::SBTypeNameSpecifier *)new lldb::SBTypeNameSpecifier((char const *)arg1,arg2);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeNameSpecifier__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
lldb::SBTypeNameSpecifier *result = 0 ;
SWIG_check_num_args("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = (lldb::SBTypeNameSpecifier *)new lldb::SBTypeNameSpecifier((char const *)arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeNameSpecifier__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
lldb::SBType arg1 ;
lldb::SBType *argp1 ;
lldb::SBTypeNameSpecifier *result = 0 ;
SWIG_check_num_args("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",1,"lldb::SBType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("new_SBTypeNameSpecifier",1,SWIGTYPE_p_lldb__SBType);
}
arg1 = *argp1;
result = (lldb::SBTypeNameSpecifier *)new lldb::SBTypeNameSpecifier(arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeNameSpecifier__SWIG_4(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeNameSpecifier *arg1 = 0 ;
lldb::SBTypeNameSpecifier *result = 0 ;
SWIG_check_num_args("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",1,"lldb::SBTypeNameSpecifier const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("new_SBTypeNameSpecifier",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
result = (lldb::SBTypeNameSpecifier *)new lldb::SBTypeNameSpecifier((lldb::SBTypeNameSpecifier const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeNameSpecifier(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBTypeNameSpecifier__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBType, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBTypeNameSpecifier__SWIG_3(L);
}
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeNameSpecifier, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBTypeNameSpecifier__SWIG_4(L);
}
}
if (argc == 1) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
return _wrap_new_SBTypeNameSpecifier__SWIG_2(L);
}
}
if (argc == 2) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[1]);
}
if (_v) {
return _wrap_new_SBTypeNameSpecifier__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeNameSpecifier'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTypeNameSpecifier::SBTypeNameSpecifier()\n"
" lldb::SBTypeNameSpecifier::SBTypeNameSpecifier(char const *,bool)\n"
" lldb::SBTypeNameSpecifier::SBTypeNameSpecifier(char const *)\n"
" lldb::SBTypeNameSpecifier::SBTypeNameSpecifier(lldb::SBType)\n"
" lldb::SBTypeNameSpecifier::SBTypeNameSpecifier(lldb::SBTypeNameSpecifier const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTypeNameSpecifier_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeNameSpecifier::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::IsValid",1,"lldb::SBTypeNameSpecifier const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeNameSpecifier_IsValid",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
result = (bool)((lldb::SBTypeNameSpecifier const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeNameSpecifier_IsEqualTo(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ;
lldb::SBTypeNameSpecifier *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeNameSpecifier::IsEqualTo",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::IsEqualTo",1,"lldb::SBTypeNameSpecifier *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::IsEqualTo",2,"lldb::SBTypeNameSpecifier &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeNameSpecifier_IsEqualTo",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeNameSpecifier_IsEqualTo",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
result = (bool)(arg1)->IsEqualTo(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeNameSpecifier_GetName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBTypeNameSpecifier::GetName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::GetName",1,"lldb::SBTypeNameSpecifier *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeNameSpecifier_GetName",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
result = (char *)(arg1)->GetName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeNameSpecifier_GetType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBTypeNameSpecifier::GetType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::GetType",1,"lldb::SBTypeNameSpecifier *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeNameSpecifier_GetType",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
result = (arg1)->GetType();
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeNameSpecifier_IsRegex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeNameSpecifier::IsRegex",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::IsRegex",1,"lldb::SBTypeNameSpecifier *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeNameSpecifier_IsRegex",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
result = (bool)(arg1)->IsRegex();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeNameSpecifier_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ;
lldb::SBStream *arg2 = 0 ;
lldb::DescriptionLevel arg3 ;
bool result;
SWIG_check_num_args("lldb::SBTypeNameSpecifier::GetDescription",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::GetDescription",1,"lldb::SBTypeNameSpecifier *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::GetDescription",2,"lldb::SBStream &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::GetDescription",3,"lldb::DescriptionLevel");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeNameSpecifier_GetDescription",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBTypeNameSpecifier_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3);
result = (bool)(arg1)->GetDescription(*arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeNameSpecifier___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ;
lldb::SBTypeNameSpecifier *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeNameSpecifier::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::operator ==",1,"lldb::SBTypeNameSpecifier *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::operator ==",2,"lldb::SBTypeNameSpecifier &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeNameSpecifier___eq",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeNameSpecifier___eq",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
result = (bool)(arg1)->operator ==(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeNameSpecifier___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBTypeNameSpecifier::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::__str__",1,"lldb::SBTypeNameSpecifier *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){
SWIG_fail_ptr("SBTypeNameSpecifier___tostring",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier);
}
result = lldb_SBTypeNameSpecifier___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBTypeNameSpecifier(void *obj) {
lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBTypeNameSpecifier(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBTypeNameSpecifier);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBTypeNameSpecifier_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBTypeNameSpecifier_methods[]= {
{ "IsValid", _wrap_SBTypeNameSpecifier_IsValid},
{ "IsEqualTo", _wrap_SBTypeNameSpecifier_IsEqualTo},
{ "GetName", _wrap_SBTypeNameSpecifier_GetName},
{ "GetType", _wrap_SBTypeNameSpecifier_GetType},
{ "IsRegex", _wrap_SBTypeNameSpecifier_IsRegex},
{ "GetDescription", _wrap_SBTypeNameSpecifier_GetDescription},
{ "__eq", _wrap_SBTypeNameSpecifier___eq},
{ "__tostring", _wrap_SBTypeNameSpecifier___tostring},
{0,0}
};
static swig_lua_method swig_SBTypeNameSpecifier_meta[] = {
{ "__eq", _wrap_SBTypeNameSpecifier___eq},
{ "__tostring", _wrap_SBTypeNameSpecifier___tostring},
{0,0}
};
static swig_lua_attribute swig_SBTypeNameSpecifier_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBTypeNameSpecifier_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBTypeNameSpecifier_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBTypeNameSpecifier_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBTypeNameSpecifier_Sf_SwigStatic = {
"SBTypeNameSpecifier",
swig_SBTypeNameSpecifier_Sf_SwigStatic_methods,
swig_SBTypeNameSpecifier_Sf_SwigStatic_attributes,
swig_SBTypeNameSpecifier_Sf_SwigStatic_constants,
swig_SBTypeNameSpecifier_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBTypeNameSpecifier_bases[] = {0};
static const char *swig_SBTypeNameSpecifier_base_names[] = {0};
static swig_lua_class _wrap_class_SBTypeNameSpecifier = { "SBTypeNameSpecifier", "SBTypeNameSpecifier", &SWIGTYPE_p_lldb__SBTypeNameSpecifier,_proxy__wrap_new_SBTypeNameSpecifier, swig_delete_SBTypeNameSpecifier, swig_SBTypeNameSpecifier_methods, swig_SBTypeNameSpecifier_attributes, &swig_SBTypeNameSpecifier_Sf_SwigStatic, swig_SBTypeNameSpecifier_meta, swig_SBTypeNameSpecifier_bases, swig_SBTypeNameSpecifier_base_names };
static int _wrap_new_SBTypeSummaryOptions__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummaryOptions *result = 0 ;
SWIG_check_num_args("lldb::SBTypeSummaryOptions::SBTypeSummaryOptions",0,0)
result = (lldb::SBTypeSummaryOptions *)new lldb::SBTypeSummaryOptions();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeSummaryOptions,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeSummaryOptions__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummaryOptions *arg1 = 0 ;
lldb::SBTypeSummaryOptions *result = 0 ;
SWIG_check_num_args("lldb::SBTypeSummaryOptions::SBTypeSummaryOptions",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeSummaryOptions::SBTypeSummaryOptions",1,"lldb::SBTypeSummaryOptions const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummaryOptions,0))){
SWIG_fail_ptr("new_SBTypeSummaryOptions",1,SWIGTYPE_p_lldb__SBTypeSummaryOptions);
}
result = (lldb::SBTypeSummaryOptions *)new lldb::SBTypeSummaryOptions((lldb::SBTypeSummaryOptions const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeSummaryOptions,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeSummaryOptions(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBTypeSummaryOptions__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeSummaryOptions, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBTypeSummaryOptions__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeSummaryOptions'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTypeSummaryOptions::SBTypeSummaryOptions()\n"
" lldb::SBTypeSummaryOptions::SBTypeSummaryOptions(lldb::SBTypeSummaryOptions const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTypeSummaryOptions_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeSummaryOptions::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummaryOptions::IsValid",1,"lldb::SBTypeSummaryOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummaryOptions,0))){
SWIG_fail_ptr("SBTypeSummaryOptions_IsValid",1,SWIGTYPE_p_lldb__SBTypeSummaryOptions);
}
result = (bool)(arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummaryOptions_GetLanguage(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) 0 ;
lldb::LanguageType result;
SWIG_check_num_args("lldb::SBTypeSummaryOptions::GetLanguage",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummaryOptions::GetLanguage",1,"lldb::SBTypeSummaryOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummaryOptions,0))){
SWIG_fail_ptr("SBTypeSummaryOptions_GetLanguage",1,SWIGTYPE_p_lldb__SBTypeSummaryOptions);
}
result = (lldb::LanguageType)(arg1)->GetLanguage();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummaryOptions_GetCapping(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) 0 ;
lldb::TypeSummaryCapping result;
SWIG_check_num_args("lldb::SBTypeSummaryOptions::GetCapping",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummaryOptions::GetCapping",1,"lldb::SBTypeSummaryOptions *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummaryOptions,0))){
SWIG_fail_ptr("SBTypeSummaryOptions_GetCapping",1,SWIGTYPE_p_lldb__SBTypeSummaryOptions);
}
result = (lldb::TypeSummaryCapping)(arg1)->GetCapping();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummaryOptions_SetLanguage(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) 0 ;
lldb::LanguageType arg2 ;
SWIG_check_num_args("lldb::SBTypeSummaryOptions::SetLanguage",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummaryOptions::SetLanguage",1,"lldb::SBTypeSummaryOptions *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeSummaryOptions::SetLanguage",2,"lldb::LanguageType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummaryOptions,0))){
SWIG_fail_ptr("SBTypeSummaryOptions_SetLanguage",1,SWIGTYPE_p_lldb__SBTypeSummaryOptions);
}
arg2 = (lldb::LanguageType)lua_tointeger(L, 2);
(arg1)->SetLanguage(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummaryOptions_SetCapping(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) 0 ;
lldb::TypeSummaryCapping arg2 ;
SWIG_check_num_args("lldb::SBTypeSummaryOptions::SetCapping",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummaryOptions::SetCapping",1,"lldb::SBTypeSummaryOptions *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeSummaryOptions::SetCapping",2,"lldb::TypeSummaryCapping");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummaryOptions,0))){
SWIG_fail_ptr("SBTypeSummaryOptions_SetCapping",1,SWIGTYPE_p_lldb__SBTypeSummaryOptions);
}
arg2 = (lldb::TypeSummaryCapping)lua_tointeger(L, 2);
(arg1)->SetCapping(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBTypeSummaryOptions(void *obj) {
lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBTypeSummaryOptions(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBTypeSummaryOptions);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBTypeSummaryOptions_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBTypeSummaryOptions_methods[]= {
{ "IsValid", _wrap_SBTypeSummaryOptions_IsValid},
{ "GetLanguage", _wrap_SBTypeSummaryOptions_GetLanguage},
{ "GetCapping", _wrap_SBTypeSummaryOptions_GetCapping},
{ "SetLanguage", _wrap_SBTypeSummaryOptions_SetLanguage},
{ "SetCapping", _wrap_SBTypeSummaryOptions_SetCapping},
{0,0}
};
static swig_lua_method swig_SBTypeSummaryOptions_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBTypeSummaryOptions_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBTypeSummaryOptions_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBTypeSummaryOptions_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBTypeSummaryOptions_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBTypeSummaryOptions_Sf_SwigStatic = {
"SBTypeSummaryOptions",
swig_SBTypeSummaryOptions_Sf_SwigStatic_methods,
swig_SBTypeSummaryOptions_Sf_SwigStatic_attributes,
swig_SBTypeSummaryOptions_Sf_SwigStatic_constants,
swig_SBTypeSummaryOptions_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBTypeSummaryOptions_bases[] = {0};
static const char *swig_SBTypeSummaryOptions_base_names[] = {0};
static swig_lua_class _wrap_class_SBTypeSummaryOptions = { "SBTypeSummaryOptions", "SBTypeSummaryOptions", &SWIGTYPE_p_lldb__SBTypeSummaryOptions,_proxy__wrap_new_SBTypeSummaryOptions, swig_delete_SBTypeSummaryOptions, swig_SBTypeSummaryOptions_methods, swig_SBTypeSummaryOptions_attributes, &swig_SBTypeSummaryOptions_Sf_SwigStatic, swig_SBTypeSummaryOptions_meta, swig_SBTypeSummaryOptions_bases, swig_SBTypeSummaryOptions_base_names };
static int _wrap_new_SBTypeSummary__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummary *result = 0 ;
SWIG_check_num_args("lldb::SBTypeSummary::SBTypeSummary",0,0)
result = (lldb::SBTypeSummary *)new lldb::SBTypeSummary();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary_CreateWithSummaryString__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
uint32_t arg2 ;
lldb::SBTypeSummary result;
SWIG_check_num_args("lldb::SBTypeSummary::CreateWithSummaryString",2,2)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::CreateWithSummaryString",1,"char const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::CreateWithSummaryString",2,"uint32_t");
arg1 = (char *)lua_tostring(L, 1);
arg2 = (uint32_t)lua_tointeger(L, 2);
result = lldb::SBTypeSummary::CreateWithSummaryString((char const *)arg1,arg2);
{
lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary((const lldb::SBTypeSummary &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary_CreateWithSummaryString__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
lldb::SBTypeSummary result;
SWIG_check_num_args("lldb::SBTypeSummary::CreateWithSummaryString",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::CreateWithSummaryString",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = lldb::SBTypeSummary::CreateWithSummaryString((char const *)arg1);
{
lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary((const lldb::SBTypeSummary &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary_CreateWithSummaryString(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
return _wrap_SBTypeSummary_CreateWithSummaryString__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBTypeSummary_CreateWithSummaryString__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTypeSummary_CreateWithSummaryString'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTypeSummary::CreateWithSummaryString(char const *,uint32_t)\n"
" lldb::SBTypeSummary::CreateWithSummaryString(char const *)\n");
lua_error(L);return 0;
}
static int _wrap_SBTypeSummary_CreateWithFunctionName__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
uint32_t arg2 ;
lldb::SBTypeSummary result;
SWIG_check_num_args("lldb::SBTypeSummary::CreateWithFunctionName",2,2)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::CreateWithFunctionName",1,"char const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::CreateWithFunctionName",2,"uint32_t");
arg1 = (char *)lua_tostring(L, 1);
arg2 = (uint32_t)lua_tointeger(L, 2);
result = lldb::SBTypeSummary::CreateWithFunctionName((char const *)arg1,arg2);
{
lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary((const lldb::SBTypeSummary &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary_CreateWithFunctionName__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
lldb::SBTypeSummary result;
SWIG_check_num_args("lldb::SBTypeSummary::CreateWithFunctionName",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::CreateWithFunctionName",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = lldb::SBTypeSummary::CreateWithFunctionName((char const *)arg1);
{
lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary((const lldb::SBTypeSummary &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary_CreateWithFunctionName(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
return _wrap_SBTypeSummary_CreateWithFunctionName__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBTypeSummary_CreateWithFunctionName__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTypeSummary_CreateWithFunctionName'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTypeSummary::CreateWithFunctionName(char const *,uint32_t)\n"
" lldb::SBTypeSummary::CreateWithFunctionName(char const *)\n");
lua_error(L);return 0;
}
static int _wrap_SBTypeSummary_CreateWithScriptCode__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
uint32_t arg2 ;
lldb::SBTypeSummary result;
SWIG_check_num_args("lldb::SBTypeSummary::CreateWithScriptCode",2,2)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::CreateWithScriptCode",1,"char const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::CreateWithScriptCode",2,"uint32_t");
arg1 = (char *)lua_tostring(L, 1);
arg2 = (uint32_t)lua_tointeger(L, 2);
result = lldb::SBTypeSummary::CreateWithScriptCode((char const *)arg1,arg2);
{
lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary((const lldb::SBTypeSummary &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary_CreateWithScriptCode__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
lldb::SBTypeSummary result;
SWIG_check_num_args("lldb::SBTypeSummary::CreateWithScriptCode",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::CreateWithScriptCode",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = lldb::SBTypeSummary::CreateWithScriptCode((char const *)arg1);
{
lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary((const lldb::SBTypeSummary &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary_CreateWithScriptCode(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
return _wrap_SBTypeSummary_CreateWithScriptCode__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBTypeSummary_CreateWithScriptCode__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTypeSummary_CreateWithScriptCode'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTypeSummary::CreateWithScriptCode(char const *,uint32_t)\n"
" lldb::SBTypeSummary::CreateWithScriptCode(char const *)\n");
lua_error(L);return 0;
}
static int _wrap_new_SBTypeSummary__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummary *arg1 = 0 ;
lldb::SBTypeSummary *result = 0 ;
SWIG_check_num_args("lldb::SBTypeSummary::SBTypeSummary",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::SBTypeSummary",1,"lldb::SBTypeSummary const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){
SWIG_fail_ptr("new_SBTypeSummary",1,SWIGTYPE_p_lldb__SBTypeSummary);
}
result = (lldb::SBTypeSummary *)new lldb::SBTypeSummary((lldb::SBTypeSummary const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeSummary(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBTypeSummary__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeSummary, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBTypeSummary__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeSummary'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTypeSummary::SBTypeSummary()\n"
" lldb::SBTypeSummary::SBTypeSummary(lldb::SBTypeSummary const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTypeSummary_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeSummary::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::IsValid",1,"lldb::SBTypeSummary const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){
SWIG_fail_ptr("SBTypeSummary_IsValid",1,SWIGTYPE_p_lldb__SBTypeSummary);
}
result = (bool)((lldb::SBTypeSummary const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary_IsEqualTo(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ;
lldb::SBTypeSummary *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeSummary::IsEqualTo",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::IsEqualTo",1,"lldb::SBTypeSummary *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::IsEqualTo",2,"lldb::SBTypeSummary &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){
SWIG_fail_ptr("SBTypeSummary_IsEqualTo",1,SWIGTYPE_p_lldb__SBTypeSummary);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeSummary,0))){
SWIG_fail_ptr("SBTypeSummary_IsEqualTo",2,SWIGTYPE_p_lldb__SBTypeSummary);
}
result = (bool)(arg1)->IsEqualTo(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary_IsFunctionCode(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeSummary::IsFunctionCode",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::IsFunctionCode",1,"lldb::SBTypeSummary *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){
SWIG_fail_ptr("SBTypeSummary_IsFunctionCode",1,SWIGTYPE_p_lldb__SBTypeSummary);
}
result = (bool)(arg1)->IsFunctionCode();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary_IsFunctionName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeSummary::IsFunctionName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::IsFunctionName",1,"lldb::SBTypeSummary *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){
SWIG_fail_ptr("SBTypeSummary_IsFunctionName",1,SWIGTYPE_p_lldb__SBTypeSummary);
}
result = (bool)(arg1)->IsFunctionName();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary_IsSummaryString(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeSummary::IsSummaryString",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::IsSummaryString",1,"lldb::SBTypeSummary *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){
SWIG_fail_ptr("SBTypeSummary_IsSummaryString",1,SWIGTYPE_p_lldb__SBTypeSummary);
}
result = (bool)(arg1)->IsSummaryString();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary_GetData(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBTypeSummary::GetData",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::GetData",1,"lldb::SBTypeSummary *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){
SWIG_fail_ptr("SBTypeSummary_GetData",1,SWIGTYPE_p_lldb__SBTypeSummary);
}
result = (char *)(arg1)->GetData();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary_SetSummaryString(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBTypeSummary::SetSummaryString",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::SetSummaryString",1,"lldb::SBTypeSummary *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::SetSummaryString",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){
SWIG_fail_ptr("SBTypeSummary_SetSummaryString",1,SWIGTYPE_p_lldb__SBTypeSummary);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetSummaryString((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary_SetFunctionName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBTypeSummary::SetFunctionName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::SetFunctionName",1,"lldb::SBTypeSummary *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::SetFunctionName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){
SWIG_fail_ptr("SBTypeSummary_SetFunctionName",1,SWIGTYPE_p_lldb__SBTypeSummary);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetFunctionName((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary_SetFunctionCode(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBTypeSummary::SetFunctionCode",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::SetFunctionCode",1,"lldb::SBTypeSummary *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::SetFunctionCode",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){
SWIG_fail_ptr("SBTypeSummary_SetFunctionCode",1,SWIGTYPE_p_lldb__SBTypeSummary);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetFunctionCode((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary_GetOptions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTypeSummary::GetOptions",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::GetOptions",1,"lldb::SBTypeSummary *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){
SWIG_fail_ptr("SBTypeSummary_GetOptions",1,SWIGTYPE_p_lldb__SBTypeSummary);
}
result = (uint32_t)(arg1)->GetOptions();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary_SetOptions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBTypeSummary::SetOptions",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::SetOptions",1,"lldb::SBTypeSummary *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::SetOptions",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){
SWIG_fail_ptr("SBTypeSummary_SetOptions",1,SWIGTYPE_p_lldb__SBTypeSummary);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetOptions(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ;
lldb::SBStream *arg2 = 0 ;
lldb::DescriptionLevel arg3 ;
bool result;
SWIG_check_num_args("lldb::SBTypeSummary::GetDescription",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::GetDescription",1,"lldb::SBTypeSummary *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::GetDescription",2,"lldb::SBStream &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTypeSummary::GetDescription",3,"lldb::DescriptionLevel");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){
SWIG_fail_ptr("SBTypeSummary_GetDescription",1,SWIGTYPE_p_lldb__SBTypeSummary);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBTypeSummary_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3);
result = (bool)(arg1)->GetDescription(*arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ;
lldb::SBTypeSummary *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeSummary::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::operator ==",1,"lldb::SBTypeSummary *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::operator ==",2,"lldb::SBTypeSummary &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){
SWIG_fail_ptr("SBTypeSummary___eq",1,SWIGTYPE_p_lldb__SBTypeSummary);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeSummary,0))){
SWIG_fail_ptr("SBTypeSummary___eq",2,SWIGTYPE_p_lldb__SBTypeSummary);
}
result = (bool)(arg1)->operator ==(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSummary___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBTypeSummary::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::__str__",1,"lldb::SBTypeSummary *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){
SWIG_fail_ptr("SBTypeSummary___tostring",1,SWIGTYPE_p_lldb__SBTypeSummary);
}
result = lldb_SBTypeSummary___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBTypeSummary(void *obj) {
lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBTypeSummary(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBTypeSummary);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBTypeSummary_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBTypeSummary_methods[]= {
{ "IsValid", _wrap_SBTypeSummary_IsValid},
{ "IsEqualTo", _wrap_SBTypeSummary_IsEqualTo},
{ "IsFunctionCode", _wrap_SBTypeSummary_IsFunctionCode},
{ "IsFunctionName", _wrap_SBTypeSummary_IsFunctionName},
{ "IsSummaryString", _wrap_SBTypeSummary_IsSummaryString},
{ "GetData", _wrap_SBTypeSummary_GetData},
{ "SetSummaryString", _wrap_SBTypeSummary_SetSummaryString},
{ "SetFunctionName", _wrap_SBTypeSummary_SetFunctionName},
{ "SetFunctionCode", _wrap_SBTypeSummary_SetFunctionCode},
{ "GetOptions", _wrap_SBTypeSummary_GetOptions},
{ "SetOptions", _wrap_SBTypeSummary_SetOptions},
{ "GetDescription", _wrap_SBTypeSummary_GetDescription},
{ "__eq", _wrap_SBTypeSummary___eq},
{ "__tostring", _wrap_SBTypeSummary___tostring},
{0,0}
};
static swig_lua_method swig_SBTypeSummary_meta[] = {
{ "__eq", _wrap_SBTypeSummary___eq},
{ "__tostring", _wrap_SBTypeSummary___tostring},
{0,0}
};
static swig_lua_attribute swig_SBTypeSummary_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBTypeSummary_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBTypeSummary_Sf_SwigStatic_methods[]= {
{ "CreateWithSummaryString", _wrap_SBTypeSummary_CreateWithSummaryString},
{ "CreateWithFunctionName", _wrap_SBTypeSummary_CreateWithFunctionName},
{ "CreateWithScriptCode", _wrap_SBTypeSummary_CreateWithScriptCode},
{0,0}
};
static swig_lua_class* swig_SBTypeSummary_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBTypeSummary_Sf_SwigStatic = {
"SBTypeSummary",
swig_SBTypeSummary_Sf_SwigStatic_methods,
swig_SBTypeSummary_Sf_SwigStatic_attributes,
swig_SBTypeSummary_Sf_SwigStatic_constants,
swig_SBTypeSummary_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBTypeSummary_bases[] = {0};
static const char *swig_SBTypeSummary_base_names[] = {0};
static swig_lua_class _wrap_class_SBTypeSummary = { "SBTypeSummary", "SBTypeSummary", &SWIGTYPE_p_lldb__SBTypeSummary,_proxy__wrap_new_SBTypeSummary, swig_delete_SBTypeSummary, swig_SBTypeSummary_methods, swig_SBTypeSummary_attributes, &swig_SBTypeSummary_Sf_SwigStatic, swig_SBTypeSummary_meta, swig_SBTypeSummary_bases, swig_SBTypeSummary_base_names };
static int _wrap_new_SBTypeSynthetic__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSynthetic *result = 0 ;
SWIG_check_num_args("lldb::SBTypeSynthetic::SBTypeSynthetic",0,0)
result = (lldb::SBTypeSynthetic *)new lldb::SBTypeSynthetic();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSynthetic_CreateWithClassName__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
uint32_t arg2 ;
lldb::SBTypeSynthetic result;
SWIG_check_num_args("lldb::SBTypeSynthetic::CreateWithClassName",2,2)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::CreateWithClassName",1,"char const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeSynthetic::CreateWithClassName",2,"uint32_t");
arg1 = (char *)lua_tostring(L, 1);
arg2 = (uint32_t)lua_tointeger(L, 2);
result = lldb::SBTypeSynthetic::CreateWithClassName((char const *)arg1,arg2);
{
lldb::SBTypeSynthetic * resultptr = new lldb::SBTypeSynthetic((const lldb::SBTypeSynthetic &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSynthetic_CreateWithClassName__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
lldb::SBTypeSynthetic result;
SWIG_check_num_args("lldb::SBTypeSynthetic::CreateWithClassName",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::CreateWithClassName",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = lldb::SBTypeSynthetic::CreateWithClassName((char const *)arg1);
{
lldb::SBTypeSynthetic * resultptr = new lldb::SBTypeSynthetic((const lldb::SBTypeSynthetic &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSynthetic_CreateWithClassName(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
return _wrap_SBTypeSynthetic_CreateWithClassName__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBTypeSynthetic_CreateWithClassName__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTypeSynthetic_CreateWithClassName'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTypeSynthetic::CreateWithClassName(char const *,uint32_t)\n"
" lldb::SBTypeSynthetic::CreateWithClassName(char const *)\n");
lua_error(L);return 0;
}
static int _wrap_SBTypeSynthetic_CreateWithScriptCode__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
uint32_t arg2 ;
lldb::SBTypeSynthetic result;
SWIG_check_num_args("lldb::SBTypeSynthetic::CreateWithScriptCode",2,2)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::CreateWithScriptCode",1,"char const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeSynthetic::CreateWithScriptCode",2,"uint32_t");
arg1 = (char *)lua_tostring(L, 1);
arg2 = (uint32_t)lua_tointeger(L, 2);
result = lldb::SBTypeSynthetic::CreateWithScriptCode((char const *)arg1,arg2);
{
lldb::SBTypeSynthetic * resultptr = new lldb::SBTypeSynthetic((const lldb::SBTypeSynthetic &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSynthetic_CreateWithScriptCode__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
char *arg1 = (char *) 0 ;
lldb::SBTypeSynthetic result;
SWIG_check_num_args("lldb::SBTypeSynthetic::CreateWithScriptCode",1,1)
if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::CreateWithScriptCode",1,"char const *");
arg1 = (char *)lua_tostring(L, 1);
result = lldb::SBTypeSynthetic::CreateWithScriptCode((char const *)arg1);
{
lldb::SBTypeSynthetic * resultptr = new lldb::SBTypeSynthetic((const lldb::SBTypeSynthetic &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSynthetic_CreateWithScriptCode(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
return _wrap_SBTypeSynthetic_CreateWithScriptCode__SWIG_1(L);
}
}
if (argc == 2) {
int _v;
{
_v = SWIG_lua_isnilstring(L,argv[0]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBTypeSynthetic_CreateWithScriptCode__SWIG_0(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTypeSynthetic_CreateWithScriptCode'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTypeSynthetic::CreateWithScriptCode(char const *,uint32_t)\n"
" lldb::SBTypeSynthetic::CreateWithScriptCode(char const *)\n");
lua_error(L);return 0;
}
static int _wrap_new_SBTypeSynthetic__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSynthetic *arg1 = 0 ;
lldb::SBTypeSynthetic *result = 0 ;
SWIG_check_num_args("lldb::SBTypeSynthetic::SBTypeSynthetic",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::SBTypeSynthetic",1,"lldb::SBTypeSynthetic const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){
SWIG_fail_ptr("new_SBTypeSynthetic",1,SWIGTYPE_p_lldb__SBTypeSynthetic);
}
result = (lldb::SBTypeSynthetic *)new lldb::SBTypeSynthetic((lldb::SBTypeSynthetic const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBTypeSynthetic(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBTypeSynthetic__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeSynthetic, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBTypeSynthetic__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeSynthetic'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBTypeSynthetic::SBTypeSynthetic()\n"
" lldb::SBTypeSynthetic::SBTypeSynthetic(lldb::SBTypeSynthetic const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBTypeSynthetic_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeSynthetic::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::IsValid",1,"lldb::SBTypeSynthetic const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){
SWIG_fail_ptr("SBTypeSynthetic_IsValid",1,SWIGTYPE_p_lldb__SBTypeSynthetic);
}
result = (bool)((lldb::SBTypeSynthetic const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSynthetic_IsEqualTo(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ;
lldb::SBTypeSynthetic *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeSynthetic::IsEqualTo",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::IsEqualTo",1,"lldb::SBTypeSynthetic *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeSynthetic::IsEqualTo",2,"lldb::SBTypeSynthetic &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){
SWIG_fail_ptr("SBTypeSynthetic_IsEqualTo",1,SWIGTYPE_p_lldb__SBTypeSynthetic);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){
SWIG_fail_ptr("SBTypeSynthetic_IsEqualTo",2,SWIGTYPE_p_lldb__SBTypeSynthetic);
}
result = (bool)(arg1)->IsEqualTo(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSynthetic_IsClassCode(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeSynthetic::IsClassCode",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::IsClassCode",1,"lldb::SBTypeSynthetic *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){
SWIG_fail_ptr("SBTypeSynthetic_IsClassCode",1,SWIGTYPE_p_lldb__SBTypeSynthetic);
}
result = (bool)(arg1)->IsClassCode();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSynthetic_GetData(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBTypeSynthetic::GetData",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::GetData",1,"lldb::SBTypeSynthetic *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){
SWIG_fail_ptr("SBTypeSynthetic_GetData",1,SWIGTYPE_p_lldb__SBTypeSynthetic);
}
result = (char *)(arg1)->GetData();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSynthetic_SetClassName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBTypeSynthetic::SetClassName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::SetClassName",1,"lldb::SBTypeSynthetic *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTypeSynthetic::SetClassName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){
SWIG_fail_ptr("SBTypeSynthetic_SetClassName",1,SWIGTYPE_p_lldb__SBTypeSynthetic);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetClassName((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSynthetic_SetClassCode(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBTypeSynthetic::SetClassCode",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::SetClassCode",1,"lldb::SBTypeSynthetic *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTypeSynthetic::SetClassCode",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){
SWIG_fail_ptr("SBTypeSynthetic_SetClassCode",1,SWIGTYPE_p_lldb__SBTypeSynthetic);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetClassCode((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSynthetic_GetOptions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBTypeSynthetic::GetOptions",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::GetOptions",1,"lldb::SBTypeSynthetic *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){
SWIG_fail_ptr("SBTypeSynthetic_GetOptions",1,SWIGTYPE_p_lldb__SBTypeSynthetic);
}
result = (uint32_t)(arg1)->GetOptions();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSynthetic_SetOptions(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBTypeSynthetic::SetOptions",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::SetOptions",1,"lldb::SBTypeSynthetic *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeSynthetic::SetOptions",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){
SWIG_fail_ptr("SBTypeSynthetic_SetOptions",1,SWIGTYPE_p_lldb__SBTypeSynthetic);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetOptions(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSynthetic_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ;
lldb::SBStream *arg2 = 0 ;
lldb::DescriptionLevel arg3 ;
bool result;
SWIG_check_num_args("lldb::SBTypeSynthetic::GetDescription",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::GetDescription",1,"lldb::SBTypeSynthetic *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeSynthetic::GetDescription",2,"lldb::SBStream &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTypeSynthetic::GetDescription",3,"lldb::DescriptionLevel");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){
SWIG_fail_ptr("SBTypeSynthetic_GetDescription",1,SWIGTYPE_p_lldb__SBTypeSynthetic);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBTypeSynthetic_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3);
result = (bool)(arg1)->GetDescription(*arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSynthetic___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ;
lldb::SBTypeSynthetic *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBTypeSynthetic::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::operator ==",1,"lldb::SBTypeSynthetic *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeSynthetic::operator ==",2,"lldb::SBTypeSynthetic &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){
SWIG_fail_ptr("SBTypeSynthetic___eq",1,SWIGTYPE_p_lldb__SBTypeSynthetic);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){
SWIG_fail_ptr("SBTypeSynthetic___eq",2,SWIGTYPE_p_lldb__SBTypeSynthetic);
}
result = (bool)(arg1)->operator ==(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBTypeSynthetic___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBTypeSynthetic::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::__str__",1,"lldb::SBTypeSynthetic *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){
SWIG_fail_ptr("SBTypeSynthetic___tostring",1,SWIGTYPE_p_lldb__SBTypeSynthetic);
}
result = lldb_SBTypeSynthetic___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBTypeSynthetic(void *obj) {
lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBTypeSynthetic(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBTypeSynthetic);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBTypeSynthetic_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBTypeSynthetic_methods[]= {
{ "IsValid", _wrap_SBTypeSynthetic_IsValid},
{ "IsEqualTo", _wrap_SBTypeSynthetic_IsEqualTo},
{ "IsClassCode", _wrap_SBTypeSynthetic_IsClassCode},
{ "GetData", _wrap_SBTypeSynthetic_GetData},
{ "SetClassName", _wrap_SBTypeSynthetic_SetClassName},
{ "SetClassCode", _wrap_SBTypeSynthetic_SetClassCode},
{ "GetOptions", _wrap_SBTypeSynthetic_GetOptions},
{ "SetOptions", _wrap_SBTypeSynthetic_SetOptions},
{ "GetDescription", _wrap_SBTypeSynthetic_GetDescription},
{ "__eq", _wrap_SBTypeSynthetic___eq},
{ "__tostring", _wrap_SBTypeSynthetic___tostring},
{0,0}
};
static swig_lua_method swig_SBTypeSynthetic_meta[] = {
{ "__eq", _wrap_SBTypeSynthetic___eq},
{ "__tostring", _wrap_SBTypeSynthetic___tostring},
{0,0}
};
static swig_lua_attribute swig_SBTypeSynthetic_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBTypeSynthetic_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBTypeSynthetic_Sf_SwigStatic_methods[]= {
{ "CreateWithClassName", _wrap_SBTypeSynthetic_CreateWithClassName},
{ "CreateWithScriptCode", _wrap_SBTypeSynthetic_CreateWithScriptCode},
{0,0}
};
static swig_lua_class* swig_SBTypeSynthetic_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBTypeSynthetic_Sf_SwigStatic = {
"SBTypeSynthetic",
swig_SBTypeSynthetic_Sf_SwigStatic_methods,
swig_SBTypeSynthetic_Sf_SwigStatic_attributes,
swig_SBTypeSynthetic_Sf_SwigStatic_constants,
swig_SBTypeSynthetic_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBTypeSynthetic_bases[] = {0};
static const char *swig_SBTypeSynthetic_base_names[] = {0};
static swig_lua_class _wrap_class_SBTypeSynthetic = { "SBTypeSynthetic", "SBTypeSynthetic", &SWIGTYPE_p_lldb__SBTypeSynthetic,_proxy__wrap_new_SBTypeSynthetic, swig_delete_SBTypeSynthetic, swig_SBTypeSynthetic_methods, swig_SBTypeSynthetic_attributes, &swig_SBTypeSynthetic_Sf_SwigStatic, swig_SBTypeSynthetic_meta, swig_SBTypeSynthetic_bases, swig_SBTypeSynthetic_base_names };
static int _wrap_new_SBUnixSignals__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBUnixSignals *result = 0 ;
SWIG_check_num_args("lldb::SBUnixSignals::SBUnixSignals",0,0)
result = (lldb::SBUnixSignals *)new lldb::SBUnixSignals();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBUnixSignals,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBUnixSignals__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBUnixSignals *arg1 = 0 ;
lldb::SBUnixSignals *result = 0 ;
SWIG_check_num_args("lldb::SBUnixSignals::SBUnixSignals",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::SBUnixSignals",1,"lldb::SBUnixSignals const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){
SWIG_fail_ptr("new_SBUnixSignals",1,SWIGTYPE_p_lldb__SBUnixSignals);
}
result = (lldb::SBUnixSignals *)new lldb::SBUnixSignals((lldb::SBUnixSignals const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBUnixSignals,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBUnixSignals(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBUnixSignals__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBUnixSignals, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBUnixSignals__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBUnixSignals'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBUnixSignals::SBUnixSignals()\n"
" lldb::SBUnixSignals::SBUnixSignals(lldb::SBUnixSignals const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBUnixSignals_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ;
SWIG_check_num_args("lldb::SBUnixSignals::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::Clear",1,"lldb::SBUnixSignals *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){
SWIG_fail_ptr("SBUnixSignals_Clear",1,SWIGTYPE_p_lldb__SBUnixSignals);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBUnixSignals_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBUnixSignals::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::IsValid",1,"lldb::SBUnixSignals const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){
SWIG_fail_ptr("SBUnixSignals_IsValid",1,SWIGTYPE_p_lldb__SBUnixSignals);
}
result = (bool)((lldb::SBUnixSignals const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBUnixSignals_GetSignalAsCString(lua_State* L) {
int SWIG_arg = 0;
lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ;
int32_t arg2 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBUnixSignals::GetSignalAsCString",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::GetSignalAsCString",1,"lldb::SBUnixSignals const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBUnixSignals::GetSignalAsCString",2,"int32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){
SWIG_fail_ptr("SBUnixSignals_GetSignalAsCString",1,SWIGTYPE_p_lldb__SBUnixSignals);
}
arg2 = (int32_t)lua_tointeger(L, 2);
result = (char *)((lldb::SBUnixSignals const *)arg1)->GetSignalAsCString(arg2);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBUnixSignals_GetSignalNumberFromName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ;
char *arg2 = (char *) 0 ;
int32_t result;
SWIG_check_num_args("lldb::SBUnixSignals::GetSignalNumberFromName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::GetSignalNumberFromName",1,"lldb::SBUnixSignals const *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBUnixSignals::GetSignalNumberFromName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){
SWIG_fail_ptr("SBUnixSignals_GetSignalNumberFromName",1,SWIGTYPE_p_lldb__SBUnixSignals);
}
arg2 = (char *)lua_tostring(L, 2);
result = (int32_t)((lldb::SBUnixSignals const *)arg1)->GetSignalNumberFromName((char const *)arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBUnixSignals_GetShouldSuppress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ;
int32_t arg2 ;
bool result;
SWIG_check_num_args("lldb::SBUnixSignals::GetShouldSuppress",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::GetShouldSuppress",1,"lldb::SBUnixSignals const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBUnixSignals::GetShouldSuppress",2,"int32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){
SWIG_fail_ptr("SBUnixSignals_GetShouldSuppress",1,SWIGTYPE_p_lldb__SBUnixSignals);
}
arg2 = (int32_t)lua_tointeger(L, 2);
result = (bool)((lldb::SBUnixSignals const *)arg1)->GetShouldSuppress(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBUnixSignals_SetShouldSuppress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ;
int32_t arg2 ;
bool arg3 ;
bool result;
SWIG_check_num_args("lldb::SBUnixSignals::SetShouldSuppress",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::SetShouldSuppress",1,"lldb::SBUnixSignals *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBUnixSignals::SetShouldSuppress",2,"int32_t");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBUnixSignals::SetShouldSuppress",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){
SWIG_fail_ptr("SBUnixSignals_SetShouldSuppress",1,SWIGTYPE_p_lldb__SBUnixSignals);
}
arg2 = (int32_t)lua_tointeger(L, 2);
arg3 = (lua_toboolean(L, 3)!=0);
result = (bool)(arg1)->SetShouldSuppress(arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBUnixSignals_GetShouldStop(lua_State* L) {
int SWIG_arg = 0;
lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ;
int32_t arg2 ;
bool result;
SWIG_check_num_args("lldb::SBUnixSignals::GetShouldStop",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::GetShouldStop",1,"lldb::SBUnixSignals const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBUnixSignals::GetShouldStop",2,"int32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){
SWIG_fail_ptr("SBUnixSignals_GetShouldStop",1,SWIGTYPE_p_lldb__SBUnixSignals);
}
arg2 = (int32_t)lua_tointeger(L, 2);
result = (bool)((lldb::SBUnixSignals const *)arg1)->GetShouldStop(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBUnixSignals_SetShouldStop(lua_State* L) {
int SWIG_arg = 0;
lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ;
int32_t arg2 ;
bool arg3 ;
bool result;
SWIG_check_num_args("lldb::SBUnixSignals::SetShouldStop",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::SetShouldStop",1,"lldb::SBUnixSignals *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBUnixSignals::SetShouldStop",2,"int32_t");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBUnixSignals::SetShouldStop",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){
SWIG_fail_ptr("SBUnixSignals_SetShouldStop",1,SWIGTYPE_p_lldb__SBUnixSignals);
}
arg2 = (int32_t)lua_tointeger(L, 2);
arg3 = (lua_toboolean(L, 3)!=0);
result = (bool)(arg1)->SetShouldStop(arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBUnixSignals_GetShouldNotify(lua_State* L) {
int SWIG_arg = 0;
lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ;
int32_t arg2 ;
bool result;
SWIG_check_num_args("lldb::SBUnixSignals::GetShouldNotify",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::GetShouldNotify",1,"lldb::SBUnixSignals const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBUnixSignals::GetShouldNotify",2,"int32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){
SWIG_fail_ptr("SBUnixSignals_GetShouldNotify",1,SWIGTYPE_p_lldb__SBUnixSignals);
}
arg2 = (int32_t)lua_tointeger(L, 2);
result = (bool)((lldb::SBUnixSignals const *)arg1)->GetShouldNotify(arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBUnixSignals_SetShouldNotify(lua_State* L) {
int SWIG_arg = 0;
lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ;
int32_t arg2 ;
bool arg3 ;
bool result;
SWIG_check_num_args("lldb::SBUnixSignals::SetShouldNotify",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::SetShouldNotify",1,"lldb::SBUnixSignals *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBUnixSignals::SetShouldNotify",2,"int32_t");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBUnixSignals::SetShouldNotify",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){
SWIG_fail_ptr("SBUnixSignals_SetShouldNotify",1,SWIGTYPE_p_lldb__SBUnixSignals);
}
arg2 = (int32_t)lua_tointeger(L, 2);
arg3 = (lua_toboolean(L, 3)!=0);
result = (bool)(arg1)->SetShouldNotify(arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBUnixSignals_GetNumSignals(lua_State* L) {
int SWIG_arg = 0;
lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ;
int32_t result;
SWIG_check_num_args("lldb::SBUnixSignals::GetNumSignals",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::GetNumSignals",1,"lldb::SBUnixSignals const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){
SWIG_fail_ptr("SBUnixSignals_GetNumSignals",1,SWIGTYPE_p_lldb__SBUnixSignals);
}
result = (int32_t)((lldb::SBUnixSignals const *)arg1)->GetNumSignals();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBUnixSignals_GetSignalAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ;
int32_t arg2 ;
int32_t result;
SWIG_check_num_args("lldb::SBUnixSignals::GetSignalAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::GetSignalAtIndex",1,"lldb::SBUnixSignals const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBUnixSignals::GetSignalAtIndex",2,"int32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){
SWIG_fail_ptr("SBUnixSignals_GetSignalAtIndex",1,SWIGTYPE_p_lldb__SBUnixSignals);
}
arg2 = (int32_t)lua_tointeger(L, 2);
result = (int32_t)((lldb::SBUnixSignals const *)arg1)->GetSignalAtIndex(arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBUnixSignals(void *obj) {
lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBUnixSignals(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBUnixSignals);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBUnixSignals_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBUnixSignals_methods[]= {
{ "Clear", _wrap_SBUnixSignals_Clear},
{ "IsValid", _wrap_SBUnixSignals_IsValid},
{ "GetSignalAsCString", _wrap_SBUnixSignals_GetSignalAsCString},
{ "GetSignalNumberFromName", _wrap_SBUnixSignals_GetSignalNumberFromName},
{ "GetShouldSuppress", _wrap_SBUnixSignals_GetShouldSuppress},
{ "SetShouldSuppress", _wrap_SBUnixSignals_SetShouldSuppress},
{ "GetShouldStop", _wrap_SBUnixSignals_GetShouldStop},
{ "SetShouldStop", _wrap_SBUnixSignals_SetShouldStop},
{ "GetShouldNotify", _wrap_SBUnixSignals_GetShouldNotify},
{ "SetShouldNotify", _wrap_SBUnixSignals_SetShouldNotify},
{ "GetNumSignals", _wrap_SBUnixSignals_GetNumSignals},
{ "GetSignalAtIndex", _wrap_SBUnixSignals_GetSignalAtIndex},
{0,0}
};
static swig_lua_method swig_SBUnixSignals_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBUnixSignals_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBUnixSignals_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBUnixSignals_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBUnixSignals_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBUnixSignals_Sf_SwigStatic = {
"SBUnixSignals",
swig_SBUnixSignals_Sf_SwigStatic_methods,
swig_SBUnixSignals_Sf_SwigStatic_attributes,
swig_SBUnixSignals_Sf_SwigStatic_constants,
swig_SBUnixSignals_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBUnixSignals_bases[] = {0};
static const char *swig_SBUnixSignals_base_names[] = {0};
static swig_lua_class _wrap_class_SBUnixSignals = { "SBUnixSignals", "SBUnixSignals", &SWIGTYPE_p_lldb__SBUnixSignals,_proxy__wrap_new_SBUnixSignals, swig_delete_SBUnixSignals, swig_SBUnixSignals_methods, swig_SBUnixSignals_attributes, &swig_SBUnixSignals_Sf_SwigStatic, swig_SBUnixSignals_meta, swig_SBUnixSignals_bases, swig_SBUnixSignals_base_names };
static int _wrap_new_SBValue__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *result = 0 ;
SWIG_check_num_args("lldb::SBValue::SBValue",0,0)
result = (lldb::SBValue *)new lldb::SBValue();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBValue__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = 0 ;
lldb::SBValue *result = 0 ;
SWIG_check_num_args("lldb::SBValue::SBValue",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBValue::SBValue",1,"lldb::SBValue const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("new_SBValue",1,SWIGTYPE_p_lldb__SBValue);
}
result = (lldb::SBValue *)new lldb::SBValue((lldb::SBValue const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBValue(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBValue__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBValue__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBValue'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBValue::SBValue()\n"
" lldb::SBValue::SBValue(lldb::SBValue const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBValue_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBValue::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::IsValid",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_IsValid",1,SWIGTYPE_p_lldb__SBValue);
}
result = (bool)(arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
SWIG_check_num_args("lldb::SBValue::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::Clear",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_Clear",1,SWIGTYPE_p_lldb__SBValue);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetError(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBValue::GetError",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetError",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetError",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->GetError();
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::user_id_t result;
SWIG_check_num_args("lldb::SBValue::GetID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetID",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetID",1,SWIGTYPE_p_lldb__SBValue);
}
result = (lldb::user_id_t)(arg1)->GetID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBValue::GetName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetName",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetName",1,SWIGTYPE_p_lldb__SBValue);
}
result = (char *)(arg1)->GetName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetTypeName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBValue::GetTypeName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetTypeName",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetTypeName",1,SWIGTYPE_p_lldb__SBValue);
}
result = (char *)(arg1)->GetTypeName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetDisplayTypeName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBValue::GetDisplayTypeName",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetDisplayTypeName",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetDisplayTypeName",1,SWIGTYPE_p_lldb__SBValue);
}
result = (char *)(arg1)->GetDisplayTypeName();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetByteSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBValue::GetByteSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetByteSize",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetByteSize",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->GetByteSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_IsInScope(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBValue::IsInScope",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::IsInScope",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_IsInScope",1,SWIGTYPE_p_lldb__SBValue);
}
result = (bool)(arg1)->IsInScope();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetFormat(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::Format result;
SWIG_check_num_args("lldb::SBValue::GetFormat",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetFormat",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetFormat",1,SWIGTYPE_p_lldb__SBValue);
}
result = (lldb::Format)(arg1)->GetFormat();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_SetFormat(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::Format arg2 ;
SWIG_check_num_args("lldb::SBValue::SetFormat",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::SetFormat",1,"lldb::SBValue *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::SetFormat",2,"lldb::Format");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_SetFormat",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (lldb::Format)lua_tointeger(L, 2);
(arg1)->SetFormat(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetValue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBValue::GetValue",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValue",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetValue",1,SWIGTYPE_p_lldb__SBValue);
}
result = (char *)(arg1)->GetValue();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetValueAsSigned__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBError *arg2 = 0 ;
int64_t arg3 ;
int64_t result;
SWIG_check_num_args("lldb::SBValue::GetValueAsSigned",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueAsSigned",1,"lldb::SBValue *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::GetValueAsSigned",2,"lldb::SBError &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBValue::GetValueAsSigned",3,"int64_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetValueAsSigned",1,SWIGTYPE_p_lldb__SBValue);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBValue_GetValueAsSigned",2,SWIGTYPE_p_lldb__SBError);
}
arg3 = (int64_t)lua_tointeger(L, 3);
result = (int64_t)(arg1)->GetValueAsSigned(*arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetValueAsSigned__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBError *arg2 = 0 ;
int64_t result;
SWIG_check_num_args("lldb::SBValue::GetValueAsSigned",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueAsSigned",1,"lldb::SBValue *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::GetValueAsSigned",2,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetValueAsSigned",1,SWIGTYPE_p_lldb__SBValue);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBValue_GetValueAsSigned",2,SWIGTYPE_p_lldb__SBError);
}
result = (int64_t)(arg1)->GetValueAsSigned(*arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetValueAsUnsigned__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBError *arg2 = 0 ;
uint64_t arg3 ;
uint64_t result;
SWIG_check_num_args("lldb::SBValue::GetValueAsUnsigned",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueAsUnsigned",1,"lldb::SBValue *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::GetValueAsUnsigned",2,"lldb::SBError &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBValue::GetValueAsUnsigned",3,"uint64_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetValueAsUnsigned",1,SWIGTYPE_p_lldb__SBValue);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBValue_GetValueAsUnsigned",2,SWIGTYPE_p_lldb__SBError);
}
arg3 = (uint64_t)lua_tointeger(L, 3);
result = (uint64_t)(arg1)->GetValueAsUnsigned(*arg2,arg3);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetValueAsUnsigned__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBError *arg2 = 0 ;
uint64_t result;
SWIG_check_num_args("lldb::SBValue::GetValueAsUnsigned",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueAsUnsigned",1,"lldb::SBValue *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::GetValueAsUnsigned",2,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetValueAsUnsigned",1,SWIGTYPE_p_lldb__SBValue);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBValue_GetValueAsUnsigned",2,SWIGTYPE_p_lldb__SBError);
}
result = (uint64_t)(arg1)->GetValueAsUnsigned(*arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetValueAsSigned__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
int64_t arg2 ;
int64_t result;
SWIG_check_num_args("lldb::SBValue::GetValueAsSigned",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueAsSigned",1,"lldb::SBValue *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::GetValueAsSigned",2,"int64_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetValueAsSigned",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (int64_t)lua_tointeger(L, 2);
result = (int64_t)(arg1)->GetValueAsSigned(arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetValueAsSigned__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
int64_t result;
SWIG_check_num_args("lldb::SBValue::GetValueAsSigned",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueAsSigned",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetValueAsSigned",1,SWIGTYPE_p_lldb__SBValue);
}
result = (int64_t)(arg1)->GetValueAsSigned();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetValueAsSigned(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBValue_GetValueAsSigned__SWIG_3(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBValue_GetValueAsSigned__SWIG_1(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBValue_GetValueAsSigned__SWIG_2(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBValue_GetValueAsSigned__SWIG_0(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBValue_GetValueAsSigned'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBValue::GetValueAsSigned(lldb::SBError &,int64_t)\n"
" lldb::SBValue::GetValueAsSigned(lldb::SBError &)\n"
" lldb::SBValue::GetValueAsSigned(int64_t)\n"
" lldb::SBValue::GetValueAsSigned()\n");
lua_error(L);return 0;
}
static int _wrap_SBValue_GetValueAsUnsigned__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
uint64_t arg2 ;
uint64_t result;
SWIG_check_num_args("lldb::SBValue::GetValueAsUnsigned",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueAsUnsigned",1,"lldb::SBValue *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::GetValueAsUnsigned",2,"uint64_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetValueAsUnsigned",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (uint64_t)lua_tointeger(L, 2);
result = (uint64_t)(arg1)->GetValueAsUnsigned(arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetValueAsUnsigned__SWIG_3(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
uint64_t result;
SWIG_check_num_args("lldb::SBValue::GetValueAsUnsigned",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueAsUnsigned",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetValueAsUnsigned",1,SWIGTYPE_p_lldb__SBValue);
}
result = (uint64_t)(arg1)->GetValueAsUnsigned();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetValueAsUnsigned(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBValue_GetValueAsUnsigned__SWIG_3(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBValue_GetValueAsUnsigned__SWIG_1(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBValue_GetValueAsUnsigned__SWIG_2(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBValue_GetValueAsUnsigned__SWIG_0(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBValue_GetValueAsUnsigned'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBValue::GetValueAsUnsigned(lldb::SBError &,uint64_t)\n"
" lldb::SBValue::GetValueAsUnsigned(lldb::SBError &)\n"
" lldb::SBValue::GetValueAsUnsigned(uint64_t)\n"
" lldb::SBValue::GetValueAsUnsigned()\n");
lua_error(L);return 0;
}
static int _wrap_SBValue_GetValueType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::ValueType result;
SWIG_check_num_args("lldb::SBValue::GetValueType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueType",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetValueType",1,SWIGTYPE_p_lldb__SBValue);
}
result = (lldb::ValueType)(arg1)->GetValueType();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetValueDidChange(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBValue::GetValueDidChange",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueDidChange",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetValueDidChange",1,SWIGTYPE_p_lldb__SBValue);
}
result = (bool)(arg1)->GetValueDidChange();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetSummary__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBValue::GetSummary",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetSummary",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetSummary",1,SWIGTYPE_p_lldb__SBValue);
}
result = (char *)(arg1)->GetSummary();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetSummary__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBStream *arg2 = 0 ;
lldb::SBTypeSummaryOptions *arg3 = 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBValue::GetSummary",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetSummary",1,"lldb::SBValue *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::GetSummary",2,"lldb::SBStream &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBValue::GetSummary",3,"lldb::SBTypeSummaryOptions &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetSummary",1,SWIGTYPE_p_lldb__SBValue);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBValue_GetSummary",2,SWIGTYPE_p_lldb__SBStream);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBTypeSummaryOptions,0))){
SWIG_fail_ptr("SBValue_GetSummary",3,SWIGTYPE_p_lldb__SBTypeSummaryOptions);
}
result = (char *)(arg1)->GetSummary(*arg2,*arg3);
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetSummary(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBValue_GetSummary__SWIG_0(L);
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeSummaryOptions, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBValue_GetSummary__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBValue_GetSummary'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBValue::GetSummary()\n"
" lldb::SBValue::GetSummary(lldb::SBStream &,lldb::SBTypeSummaryOptions &)\n");
lua_error(L);return 0;
}
static int _wrap_SBValue_GetObjectDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBValue::GetObjectDescription",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetObjectDescription",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetObjectDescription",1,SWIGTYPE_p_lldb__SBValue);
}
result = (char *)(arg1)->GetObjectDescription();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetDynamicValue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::DynamicValueType arg2 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::GetDynamicValue",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetDynamicValue",1,"lldb::SBValue *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::GetDynamicValue",2,"lldb::DynamicValueType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetDynamicValue",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (lldb::DynamicValueType)lua_tointeger(L, 2);
result = (arg1)->GetDynamicValue(arg2);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetStaticValue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::GetStaticValue",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetStaticValue",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetStaticValue",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->GetStaticValue();
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetNonSyntheticValue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::GetNonSyntheticValue",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetNonSyntheticValue",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetNonSyntheticValue",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->GetNonSyntheticValue();
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetPreferDynamicValue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::DynamicValueType result;
SWIG_check_num_args("lldb::SBValue::GetPreferDynamicValue",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetPreferDynamicValue",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetPreferDynamicValue",1,SWIGTYPE_p_lldb__SBValue);
}
result = (lldb::DynamicValueType)(arg1)->GetPreferDynamicValue();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_SetPreferDynamicValue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::DynamicValueType arg2 ;
SWIG_check_num_args("lldb::SBValue::SetPreferDynamicValue",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::SetPreferDynamicValue",1,"lldb::SBValue *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::SetPreferDynamicValue",2,"lldb::DynamicValueType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_SetPreferDynamicValue",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (lldb::DynamicValueType)lua_tointeger(L, 2);
(arg1)->SetPreferDynamicValue(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetPreferSyntheticValue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBValue::GetPreferSyntheticValue",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetPreferSyntheticValue",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetPreferSyntheticValue",1,SWIGTYPE_p_lldb__SBValue);
}
result = (bool)(arg1)->GetPreferSyntheticValue();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_SetPreferSyntheticValue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBValue::SetPreferSyntheticValue",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::SetPreferSyntheticValue",1,"lldb::SBValue *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBValue::SetPreferSyntheticValue",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_SetPreferSyntheticValue",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetPreferSyntheticValue(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_IsDynamic(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBValue::IsDynamic",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::IsDynamic",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_IsDynamic",1,SWIGTYPE_p_lldb__SBValue);
}
result = (bool)(arg1)->IsDynamic();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_IsSynthetic(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBValue::IsSynthetic",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::IsSynthetic",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_IsSynthetic",1,SWIGTYPE_p_lldb__SBValue);
}
result = (bool)(arg1)->IsSynthetic();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_IsSyntheticChildrenGenerated(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBValue::IsSyntheticChildrenGenerated",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::IsSyntheticChildrenGenerated",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_IsSyntheticChildrenGenerated",1,SWIGTYPE_p_lldb__SBValue);
}
result = (bool)(arg1)->IsSyntheticChildrenGenerated();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_SetSyntheticChildrenGenerated(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBValue::SetSyntheticChildrenGenerated",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::SetSyntheticChildrenGenerated",1,"lldb::SBValue *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBValue::SetSyntheticChildrenGenerated",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_SetSyntheticChildrenGenerated",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetSyntheticChildrenGenerated(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetLocation(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBValue::GetLocation",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetLocation",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetLocation",1,SWIGTYPE_p_lldb__SBValue);
}
result = (char *)(arg1)->GetLocation();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_SetValueFromCString__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *arg2 = (char *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBValue::SetValueFromCString",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::SetValueFromCString",1,"lldb::SBValue *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::SetValueFromCString",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_SetValueFromCString",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (char *)lua_tostring(L, 2);
result = (bool)(arg1)->SetValueFromCString((char const *)arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_SetValueFromCString__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBError *arg3 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBValue::SetValueFromCString",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::SetValueFromCString",1,"lldb::SBValue *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::SetValueFromCString",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBValue::SetValueFromCString",3,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_SetValueFromCString",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBValue_SetValueFromCString",3,SWIGTYPE_p_lldb__SBError);
}
result = (bool)(arg1)->SetValueFromCString((char const *)arg2,*arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_SetValueFromCString(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBValue_SetValueFromCString__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBValue_SetValueFromCString__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBValue_SetValueFromCString'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBValue::SetValueFromCString(char const *)\n"
" lldb::SBValue::SetValueFromCString(char const *,lldb::SBError &)\n");
lua_error(L);return 0;
}
static int _wrap_SBValue_GetTypeFormat(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBTypeFormat result;
SWIG_check_num_args("lldb::SBValue::GetTypeFormat",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetTypeFormat",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetTypeFormat",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->GetTypeFormat();
{
lldb::SBTypeFormat * resultptr = new lldb::SBTypeFormat((const lldb::SBTypeFormat &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetTypeSummary(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBTypeSummary result;
SWIG_check_num_args("lldb::SBValue::GetTypeSummary",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetTypeSummary",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetTypeSummary",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->GetTypeSummary();
{
lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary((const lldb::SBTypeSummary &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetTypeFilter(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBTypeFilter result;
SWIG_check_num_args("lldb::SBValue::GetTypeFilter",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetTypeFilter",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetTypeFilter",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->GetTypeFilter();
{
lldb::SBTypeFilter * resultptr = new lldb::SBTypeFilter((const lldb::SBTypeFilter &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeFilter,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetTypeSynthetic(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBTypeSynthetic result;
SWIG_check_num_args("lldb::SBValue::GetTypeSynthetic",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetTypeSynthetic",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetTypeSynthetic",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->GetTypeSynthetic();
{
lldb::SBTypeSynthetic * resultptr = new lldb::SBTypeSynthetic((const lldb::SBTypeSynthetic &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetChildAtIndex__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
uint32_t arg2 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::GetChildAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetChildAtIndex",1,"lldb::SBValue *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::GetChildAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetChildAtIndex",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetChildAtIndex(arg2);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetChildAtIndex__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
uint32_t arg2 ;
lldb::DynamicValueType arg3 ;
bool arg4 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::GetChildAtIndex",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetChildAtIndex",1,"lldb::SBValue *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::GetChildAtIndex",2,"uint32_t");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBValue::GetChildAtIndex",3,"lldb::DynamicValueType");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBValue::GetChildAtIndex",4,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetChildAtIndex",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
arg3 = (lldb::DynamicValueType)lua_tointeger(L, 3);
arg4 = (lua_toboolean(L, 4)!=0);
result = (arg1)->GetChildAtIndex(arg2,arg3,arg4);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetChildAtIndex(lua_State* L) {
int argc;
int argv[5]={
1,2,3,4,5
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBValue_GetChildAtIndex__SWIG_0(L);
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
{
_v = lua_isboolean(L,argv[3]);
}
if (_v) {
return _wrap_SBValue_GetChildAtIndex__SWIG_1(L);
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBValue_GetChildAtIndex'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBValue::GetChildAtIndex(uint32_t)\n"
" lldb::SBValue::GetChildAtIndex(uint32_t,lldb::DynamicValueType,bool)\n");
lua_error(L);return 0;
}
static int _wrap_SBValue_CreateChildAtOffset(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *arg2 = (char *) 0 ;
uint32_t arg3 ;
lldb::SBType arg4 ;
lldb::SBType *argp4 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::CreateChildAtOffset",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::CreateChildAtOffset",1,"lldb::SBValue *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::CreateChildAtOffset",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBValue::CreateChildAtOffset",3,"uint32_t");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBValue::CreateChildAtOffset",4,"lldb::SBType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_CreateChildAtOffset",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBValue_CreateChildAtOffset",4,SWIGTYPE_p_lldb__SBType);
}
arg4 = *argp4;
result = (arg1)->CreateChildAtOffset((char const *)arg2,arg3,arg4);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_Cast(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBType arg2 ;
lldb::SBType *argp2 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::Cast",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::Cast",1,"lldb::SBValue *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::Cast",2,"lldb::SBType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_Cast",1,SWIGTYPE_p_lldb__SBValue);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBValue_Cast",2,SWIGTYPE_p_lldb__SBType);
}
arg2 = *argp2;
result = (arg1)->Cast(arg2);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_CreateValueFromExpression__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::CreateValueFromExpression",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::CreateValueFromExpression",1,"lldb::SBValue *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::CreateValueFromExpression",2,"char const *");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBValue::CreateValueFromExpression",3,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_CreateValueFromExpression",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (char *)lua_tostring(L, 3);
result = (arg1)->CreateValueFromExpression((char const *)arg2,(char const *)arg3);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_CreateValueFromExpression__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
lldb::SBExpressionOptions *arg4 = 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::CreateValueFromExpression",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::CreateValueFromExpression",1,"lldb::SBValue *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::CreateValueFromExpression",2,"char const *");
if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBValue::CreateValueFromExpression",3,"char const *");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBValue::CreateValueFromExpression",4,"lldb::SBExpressionOptions &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_CreateValueFromExpression",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (char *)lua_tostring(L, 3);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBValue_CreateValueFromExpression",4,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = (arg1)->CreateValueFromExpression((char const *)arg2,(char const *)arg3,*arg4);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_CreateValueFromExpression(lua_State* L) {
int argc;
int argv[5]={
1,2,3,4,5
};
argc = lua_gettop(L);
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[2]);
}
if (_v) {
return _wrap_SBValue_CreateValueFromExpression__SWIG_0(L);
}
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[2]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBValue_CreateValueFromExpression__SWIG_1(L);
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBValue_CreateValueFromExpression'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBValue::CreateValueFromExpression(char const *,char const *)\n"
" lldb::SBValue::CreateValueFromExpression(char const *,char const *,lldb::SBExpressionOptions &)\n");
lua_error(L);return 0;
}
static int _wrap_SBValue_CreateValueFromAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *arg2 = (char *) 0 ;
lldb::addr_t arg3 ;
lldb::SBType arg4 ;
lldb::SBType *argp4 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::CreateValueFromAddress",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::CreateValueFromAddress",1,"lldb::SBValue *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::CreateValueFromAddress",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBValue::CreateValueFromAddress",3,"lldb::addr_t");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBValue::CreateValueFromAddress",4,"lldb::SBType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_CreateValueFromAddress",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (lldb::addr_t)lua_tointeger(L, 3);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBValue_CreateValueFromAddress",4,SWIGTYPE_p_lldb__SBType);
}
arg4 = *argp4;
result = (arg1)->CreateValueFromAddress((char const *)arg2,arg3,arg4);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_CreateValueFromData(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBData arg3 ;
lldb::SBType arg4 ;
lldb::SBData *argp3 ;
lldb::SBType *argp4 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::CreateValueFromData",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::CreateValueFromData",1,"lldb::SBValue *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::CreateValueFromData",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBValue::CreateValueFromData",3,"lldb::SBData");
if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBValue::CreateValueFromData",4,"lldb::SBType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_CreateValueFromData",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBValue_CreateValueFromData",3,SWIGTYPE_p_lldb__SBData);
}
arg3 = *argp3;
if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_lldb__SBType,0))){
SWIG_fail_ptr("SBValue_CreateValueFromData",4,SWIGTYPE_p_lldb__SBType);
}
arg4 = *argp4;
result = (arg1)->CreateValueFromData((char const *)arg2,arg3,arg4);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBType result;
SWIG_check_num_args("lldb::SBValue::GetType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetType",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetType",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->GetType();
{
lldb::SBType * resultptr = new lldb::SBType((const lldb::SBType &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetIndexOfChildWithName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *arg2 = (char *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBValue::GetIndexOfChildWithName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetIndexOfChildWithName",1,"lldb::SBValue *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::GetIndexOfChildWithName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetIndexOfChildWithName",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (char *)lua_tostring(L, 2);
result = (uint32_t)(arg1)->GetIndexOfChildWithName((char const *)arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetChildMemberWithName__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::GetChildMemberWithName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetChildMemberWithName",1,"lldb::SBValue *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::GetChildMemberWithName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetChildMemberWithName",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->GetChildMemberWithName((char const *)arg2);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetChildMemberWithName__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *arg2 = (char *) 0 ;
lldb::DynamicValueType arg3 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::GetChildMemberWithName",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetChildMemberWithName",1,"lldb::SBValue *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::GetChildMemberWithName",2,"char const *");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBValue::GetChildMemberWithName",3,"lldb::DynamicValueType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetChildMemberWithName",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (char *)lua_tostring(L, 2);
arg3 = (lldb::DynamicValueType)lua_tointeger(L, 3);
result = (arg1)->GetChildMemberWithName((char const *)arg2,arg3);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetChildMemberWithName(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBValue_GetChildMemberWithName__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBValue_GetChildMemberWithName__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBValue_GetChildMemberWithName'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBValue::GetChildMemberWithName(char const *)\n"
" lldb::SBValue::GetChildMemberWithName(char const *,lldb::DynamicValueType)\n");
lua_error(L);return 0;
}
static int _wrap_SBValue_GetValueForExpressionPath(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::GetValueForExpressionPath",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueForExpressionPath",1,"lldb::SBValue *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::GetValueForExpressionPath",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetValueForExpressionPath",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->GetValueForExpressionPath((char const *)arg2);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetDeclaration(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBDeclaration result;
SWIG_check_num_args("lldb::SBValue::GetDeclaration",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetDeclaration",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetDeclaration",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->GetDeclaration();
{
lldb::SBDeclaration * resultptr = new lldb::SBDeclaration((const lldb::SBDeclaration &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBDeclaration,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_MightHaveChildren(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBValue::MightHaveChildren",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::MightHaveChildren",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_MightHaveChildren",1,SWIGTYPE_p_lldb__SBValue);
}
result = (bool)(arg1)->MightHaveChildren();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_IsRuntimeSupportValue(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBValue::IsRuntimeSupportValue",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::IsRuntimeSupportValue",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_IsRuntimeSupportValue",1,SWIGTYPE_p_lldb__SBValue);
}
result = (bool)(arg1)->IsRuntimeSupportValue();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetNumChildren__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBValue::GetNumChildren",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetNumChildren",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetNumChildren",1,SWIGTYPE_p_lldb__SBValue);
}
result = (uint32_t)(arg1)->GetNumChildren();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetNumChildren__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
uint32_t arg2 ;
uint32_t result;
SWIG_check_num_args("lldb::SBValue::GetNumChildren",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetNumChildren",1,"lldb::SBValue *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::GetNumChildren",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetNumChildren",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (uint32_t)(arg1)->GetNumChildren(arg2);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetNumChildren(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBValue_GetNumChildren__SWIG_0(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBValue_GetNumChildren__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBValue_GetNumChildren'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBValue::GetNumChildren()\n"
" lldb::SBValue::GetNumChildren(uint32_t)\n");
lua_error(L);return 0;
}
static int _wrap_SBValue_GetOpaqueType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
void *result = 0 ;
SWIG_check_num_args("lldb::SBValue::GetOpaqueType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetOpaqueType",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetOpaqueType",1,SWIGTYPE_p_lldb__SBValue);
}
result = (void *)(arg1)->GetOpaqueType();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_void,0); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_Dereference(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::Dereference",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::Dereference",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_Dereference",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->Dereference();
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_AddressOf(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::AddressOf",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::AddressOf",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_AddressOf",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->AddressOf();
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_TypeIsPointerType(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBValue::TypeIsPointerType",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::TypeIsPointerType",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_TypeIsPointerType",1,SWIGTYPE_p_lldb__SBValue);
}
result = (bool)(arg1)->TypeIsPointerType();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetTarget(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBTarget result;
SWIG_check_num_args("lldb::SBValue::GetTarget",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetTarget",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetTarget",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->GetTarget();
{
lldb::SBTarget * resultptr = new lldb::SBTarget((const lldb::SBTarget &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetProcess(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBProcess result;
SWIG_check_num_args("lldb::SBValue::GetProcess",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetProcess",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetProcess",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->GetProcess();
{
lldb::SBProcess * resultptr = new lldb::SBProcess((const lldb::SBProcess &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetThread(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBThread result;
SWIG_check_num_args("lldb::SBValue::GetThread",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetThread",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetThread",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->GetThread();
{
lldb::SBThread * resultptr = new lldb::SBThread((const lldb::SBThread &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetFrame(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBFrame result;
SWIG_check_num_args("lldb::SBValue::GetFrame",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetFrame",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetFrame",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->GetFrame();
{
lldb::SBFrame * resultptr = new lldb::SBFrame((const lldb::SBFrame &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFrame,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_Watch(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
bool arg2 ;
bool arg3 ;
bool arg4 ;
lldb::SBError *arg5 = 0 ;
lldb::SBWatchpoint result;
SWIG_check_num_args("lldb::SBValue::Watch",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::Watch",1,"lldb::SBValue *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBValue::Watch",2,"bool");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBValue::Watch",3,"bool");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBValue::Watch",4,"bool");
if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBValue::Watch",5,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_Watch",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (lua_toboolean(L, 2)!=0);
arg3 = (lua_toboolean(L, 3)!=0);
arg4 = (lua_toboolean(L, 4)!=0);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBValue_Watch",5,SWIGTYPE_p_lldb__SBError);
}
result = (arg1)->Watch(arg2,arg3,arg4,*arg5);
{
lldb::SBWatchpoint * resultptr = new lldb::SBWatchpoint((const lldb::SBWatchpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBWatchpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_WatchPointee(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
bool arg2 ;
bool arg3 ;
bool arg4 ;
lldb::SBError *arg5 = 0 ;
lldb::SBWatchpoint result;
SWIG_check_num_args("lldb::SBValue::WatchPointee",5,5)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::WatchPointee",1,"lldb::SBValue *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBValue::WatchPointee",2,"bool");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBValue::WatchPointee",3,"bool");
if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBValue::WatchPointee",4,"bool");
if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBValue::WatchPointee",5,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_WatchPointee",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (lua_toboolean(L, 2)!=0);
arg3 = (lua_toboolean(L, 3)!=0);
arg4 = (lua_toboolean(L, 4)!=0);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBValue_WatchPointee",5,SWIGTYPE_p_lldb__SBError);
}
result = (arg1)->WatchPointee(arg2,arg3,arg4,*arg5);
{
lldb::SBWatchpoint * resultptr = new lldb::SBWatchpoint((const lldb::SBWatchpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBWatchpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBValue::GetDescription",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetDescription",1,"lldb::SBValue *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::GetDescription",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetDescription",1,SWIGTYPE_p_lldb__SBValue);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBValue_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetDescription(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetExpressionPath__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBValue::GetExpressionPath",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetExpressionPath",1,"lldb::SBValue *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::GetExpressionPath",2,"lldb::SBStream &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetExpressionPath",1,SWIGTYPE_p_lldb__SBValue);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBValue_GetExpressionPath",2,SWIGTYPE_p_lldb__SBStream);
}
result = (bool)(arg1)->GetExpressionPath(*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetPointeeData__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
uint32_t arg2 ;
uint32_t arg3 ;
lldb::SBData result;
SWIG_check_num_args("lldb::SBValue::GetPointeeData",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetPointeeData",1,"lldb::SBValue *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::GetPointeeData",2,"uint32_t");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBValue::GetPointeeData",3,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetPointeeData",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
arg3 = (uint32_t)lua_tointeger(L, 3);
result = (arg1)->GetPointeeData(arg2,arg3);
{
lldb::SBData * resultptr = new lldb::SBData((const lldb::SBData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetPointeeData__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
uint32_t arg2 ;
lldb::SBData result;
SWIG_check_num_args("lldb::SBValue::GetPointeeData",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetPointeeData",1,"lldb::SBValue *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::GetPointeeData",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetPointeeData",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = (arg1)->GetPointeeData(arg2);
{
lldb::SBData * resultptr = new lldb::SBData((const lldb::SBData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetPointeeData__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBData result;
SWIG_check_num_args("lldb::SBValue::GetPointeeData",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetPointeeData",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetPointeeData",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->GetPointeeData();
{
lldb::SBData * resultptr = new lldb::SBData((const lldb::SBData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetPointeeData(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 1) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBValue_GetPointeeData__SWIG_2(L);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
return _wrap_SBValue_GetPointeeData__SWIG_1(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isnumber(L,argv[1]);
}
if (_v) {
{
_v = lua_isnumber(L,argv[2]);
}
if (_v) {
return _wrap_SBValue_GetPointeeData__SWIG_0(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBValue_GetPointeeData'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBValue::GetPointeeData(uint32_t,uint32_t)\n"
" lldb::SBValue::GetPointeeData(uint32_t)\n"
" lldb::SBValue::GetPointeeData()\n");
lua_error(L);return 0;
}
static int _wrap_SBValue_GetData(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBData result;
SWIG_check_num_args("lldb::SBValue::GetData",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetData",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetData",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->GetData();
{
lldb::SBData * resultptr = new lldb::SBData((const lldb::SBData &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_SetData(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBData *arg2 = 0 ;
lldb::SBError *arg3 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBValue::SetData",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::SetData",1,"lldb::SBValue *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::SetData",2,"lldb::SBData &");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBValue::SetData",3,"lldb::SBError &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_SetData",1,SWIGTYPE_p_lldb__SBValue);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBData,0))){
SWIG_fail_ptr("SBValue_SetData",2,SWIGTYPE_p_lldb__SBData);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){
SWIG_fail_ptr("SBValue_SetData",3,SWIGTYPE_p_lldb__SBError);
}
result = (bool)(arg1)->SetData(*arg2,*arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_Clone(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::Clone",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::Clone",1,"lldb::SBValue *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::Clone",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_Clone",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (char *)lua_tostring(L, 2);
result = (arg1)->Clone((char const *)arg2);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetLoadAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBValue::GetLoadAddress",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetLoadAddress",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetLoadAddress",1,SWIGTYPE_p_lldb__SBValue);
}
result = (lldb::addr_t)(arg1)->GetLoadAddress();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBAddress result;
SWIG_check_num_args("lldb::SBValue::GetAddress",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetAddress",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetAddress",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->GetAddress();
{
lldb::SBAddress * resultptr = new lldb::SBAddress((const lldb::SBAddress &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_Persist(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::Persist",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::Persist",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_Persist",1,SWIGTYPE_p_lldb__SBValue);
}
result = (arg1)->Persist();
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetExpressionPath__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
lldb::SBStream *arg2 = 0 ;
bool arg3 ;
bool result;
SWIG_check_num_args("lldb::SBValue::GetExpressionPath",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetExpressionPath",1,"lldb::SBValue *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::GetExpressionPath",2,"lldb::SBStream &");
if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBValue::GetExpressionPath",3,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_GetExpressionPath",1,SWIGTYPE_p_lldb__SBValue);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBValue_GetExpressionPath",2,SWIGTYPE_p_lldb__SBStream);
}
arg3 = (lua_toboolean(L, 3)!=0);
result = (bool)(arg1)->GetExpressionPath(*arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_GetExpressionPath(lua_State* L) {
int argc;
int argv[4]={
1,2,3,4
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBValue_GetExpressionPath__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = lua_isboolean(L,argv[2]);
}
if (_v) {
return _wrap_SBValue_GetExpressionPath__SWIG_1(L);
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBValue_GetExpressionPath'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBValue::GetExpressionPath(lldb::SBStream &)\n"
" lldb::SBValue::GetExpressionPath(lldb::SBStream &,bool)\n");
lua_error(L);return 0;
}
static int _wrap_SBValue_EvaluateExpression__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::EvaluateExpression",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::EvaluateExpression",1,"lldb::SBValue const *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::EvaluateExpression",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_EvaluateExpression",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (char *)lua_tostring(L, 2);
result = ((lldb::SBValue const *)arg1)->EvaluateExpression((char const *)arg2);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_EvaluateExpression__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBExpressionOptions *arg3 = 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::EvaluateExpression",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::EvaluateExpression",1,"lldb::SBValue const *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::EvaluateExpression",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBValue::EvaluateExpression",3,"lldb::SBExpressionOptions const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_EvaluateExpression",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBValue_EvaluateExpression",3,SWIGTYPE_p_lldb__SBExpressionOptions);
}
result = ((lldb::SBValue const *)arg1)->EvaluateExpression((char const *)arg2,(lldb::SBExpressionOptions const &)*arg3);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_EvaluateExpression__SWIG_2(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBExpressionOptions *arg3 = 0 ;
char *arg4 = (char *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValue::EvaluateExpression",4,4)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::EvaluateExpression",1,"lldb::SBValue const *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::EvaluateExpression",2,"char const *");
if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBValue::EvaluateExpression",3,"lldb::SBExpressionOptions const &");
if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBValue::EvaluateExpression",4,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue_EvaluateExpression",1,SWIGTYPE_p_lldb__SBValue);
}
arg2 = (char *)lua_tostring(L, 2);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBExpressionOptions,0))){
SWIG_fail_ptr("SBValue_EvaluateExpression",3,SWIGTYPE_p_lldb__SBExpressionOptions);
}
arg4 = (char *)lua_tostring(L, 4);
result = ((lldb::SBValue const *)arg1)->EvaluateExpression((char const *)arg2,(lldb::SBExpressionOptions const &)*arg3,(char const *)arg4);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValue_EvaluateExpression(lua_State* L) {
int argc;
int argv[5]={
1,2,3,4,5
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
return _wrap_SBValue_EvaluateExpression__SWIG_0(L);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBValue_EvaluateExpression__SWIG_1(L);
}
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[1]);
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
_v = SWIG_lua_isnilstring(L,argv[3]);
}
if (_v) {
return _wrap_SBValue_EvaluateExpression__SWIG_2(L);
}
}
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBValue_EvaluateExpression'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBValue::EvaluateExpression(char const *) const\n"
" lldb::SBValue::EvaluateExpression(char const *,lldb::SBExpressionOptions const &) const\n"
" lldb::SBValue::EvaluateExpression(char const *,lldb::SBExpressionOptions const &,char const *) const\n");
lua_error(L);return 0;
}
static int _wrap_SBValue___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValue *arg1 = (lldb::SBValue *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBValue::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::__str__",1,"lldb::SBValue *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValue___tostring",1,SWIGTYPE_p_lldb__SBValue);
}
result = lldb_SBValue___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBValue(void *obj) {
lldb::SBValue *arg1 = (lldb::SBValue *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBValue(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBValue);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBValue_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBValue_methods[]= {
{ "IsValid", _wrap_SBValue_IsValid},
{ "Clear", _wrap_SBValue_Clear},
{ "GetError", _wrap_SBValue_GetError},
{ "GetID", _wrap_SBValue_GetID},
{ "GetName", _wrap_SBValue_GetName},
{ "GetTypeName", _wrap_SBValue_GetTypeName},
{ "GetDisplayTypeName", _wrap_SBValue_GetDisplayTypeName},
{ "GetByteSize", _wrap_SBValue_GetByteSize},
{ "IsInScope", _wrap_SBValue_IsInScope},
{ "GetFormat", _wrap_SBValue_GetFormat},
{ "SetFormat", _wrap_SBValue_SetFormat},
{ "GetValue", _wrap_SBValue_GetValue},
{ "GetValueAsSigned", _wrap_SBValue_GetValueAsSigned},
{ "GetValueAsUnsigned", _wrap_SBValue_GetValueAsUnsigned},
{ "GetValueType", _wrap_SBValue_GetValueType},
{ "GetValueDidChange", _wrap_SBValue_GetValueDidChange},
{ "GetSummary", _wrap_SBValue_GetSummary},
{ "GetObjectDescription", _wrap_SBValue_GetObjectDescription},
{ "GetDynamicValue", _wrap_SBValue_GetDynamicValue},
{ "GetStaticValue", _wrap_SBValue_GetStaticValue},
{ "GetNonSyntheticValue", _wrap_SBValue_GetNonSyntheticValue},
{ "GetPreferDynamicValue", _wrap_SBValue_GetPreferDynamicValue},
{ "SetPreferDynamicValue", _wrap_SBValue_SetPreferDynamicValue},
{ "GetPreferSyntheticValue", _wrap_SBValue_GetPreferSyntheticValue},
{ "SetPreferSyntheticValue", _wrap_SBValue_SetPreferSyntheticValue},
{ "IsDynamic", _wrap_SBValue_IsDynamic},
{ "IsSynthetic", _wrap_SBValue_IsSynthetic},
{ "IsSyntheticChildrenGenerated", _wrap_SBValue_IsSyntheticChildrenGenerated},
{ "SetSyntheticChildrenGenerated", _wrap_SBValue_SetSyntheticChildrenGenerated},
{ "GetLocation", _wrap_SBValue_GetLocation},
{ "SetValueFromCString", _wrap_SBValue_SetValueFromCString},
{ "GetTypeFormat", _wrap_SBValue_GetTypeFormat},
{ "GetTypeSummary", _wrap_SBValue_GetTypeSummary},
{ "GetTypeFilter", _wrap_SBValue_GetTypeFilter},
{ "GetTypeSynthetic", _wrap_SBValue_GetTypeSynthetic},
{ "GetChildAtIndex", _wrap_SBValue_GetChildAtIndex},
{ "CreateChildAtOffset", _wrap_SBValue_CreateChildAtOffset},
{ "Cast", _wrap_SBValue_Cast},
{ "CreateValueFromExpression", _wrap_SBValue_CreateValueFromExpression},
{ "CreateValueFromAddress", _wrap_SBValue_CreateValueFromAddress},
{ "CreateValueFromData", _wrap_SBValue_CreateValueFromData},
{ "GetType", _wrap_SBValue_GetType},
{ "GetIndexOfChildWithName", _wrap_SBValue_GetIndexOfChildWithName},
{ "GetChildMemberWithName", _wrap_SBValue_GetChildMemberWithName},
{ "GetValueForExpressionPath", _wrap_SBValue_GetValueForExpressionPath},
{ "GetDeclaration", _wrap_SBValue_GetDeclaration},
{ "MightHaveChildren", _wrap_SBValue_MightHaveChildren},
{ "IsRuntimeSupportValue", _wrap_SBValue_IsRuntimeSupportValue},
{ "GetNumChildren", _wrap_SBValue_GetNumChildren},
{ "GetOpaqueType", _wrap_SBValue_GetOpaqueType},
{ "Dereference", _wrap_SBValue_Dereference},
{ "AddressOf", _wrap_SBValue_AddressOf},
{ "TypeIsPointerType", _wrap_SBValue_TypeIsPointerType},
{ "GetTarget", _wrap_SBValue_GetTarget},
{ "GetProcess", _wrap_SBValue_GetProcess},
{ "GetThread", _wrap_SBValue_GetThread},
{ "GetFrame", _wrap_SBValue_GetFrame},
{ "Watch", _wrap_SBValue_Watch},
{ "WatchPointee", _wrap_SBValue_WatchPointee},
{ "GetDescription", _wrap_SBValue_GetDescription},
{ "GetPointeeData", _wrap_SBValue_GetPointeeData},
{ "GetData", _wrap_SBValue_GetData},
{ "SetData", _wrap_SBValue_SetData},
{ "Clone", _wrap_SBValue_Clone},
{ "GetLoadAddress", _wrap_SBValue_GetLoadAddress},
{ "GetAddress", _wrap_SBValue_GetAddress},
{ "Persist", _wrap_SBValue_Persist},
{ "GetExpressionPath", _wrap_SBValue_GetExpressionPath},
{ "EvaluateExpression", _wrap_SBValue_EvaluateExpression},
{ "__tostring", _wrap_SBValue___tostring},
{0,0}
};
static swig_lua_method swig_SBValue_meta[] = {
{ "__tostring", _wrap_SBValue___tostring},
{0,0}
};
static swig_lua_attribute swig_SBValue_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBValue_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBValue_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBValue_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBValue_Sf_SwigStatic = {
"SBValue",
swig_SBValue_Sf_SwigStatic_methods,
swig_SBValue_Sf_SwigStatic_attributes,
swig_SBValue_Sf_SwigStatic_constants,
swig_SBValue_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBValue_bases[] = {0};
static const char *swig_SBValue_base_names[] = {0};
static swig_lua_class _wrap_class_SBValue = { "SBValue", "SBValue", &SWIGTYPE_p_lldb__SBValue,_proxy__wrap_new_SBValue, swig_delete_SBValue, swig_SBValue_methods, swig_SBValue_attributes, &swig_SBValue_Sf_SwigStatic, swig_SBValue_meta, swig_SBValue_bases, swig_SBValue_base_names };
static int _wrap_new_SBValueList__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValueList *result = 0 ;
SWIG_check_num_args("lldb::SBValueList::SBValueList",0,0)
result = (lldb::SBValueList *)new lldb::SBValueList();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBValueList__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValueList *arg1 = 0 ;
lldb::SBValueList *result = 0 ;
SWIG_check_num_args("lldb::SBValueList::SBValueList",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBValueList::SBValueList",1,"lldb::SBValueList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){
SWIG_fail_ptr("new_SBValueList",1,SWIGTYPE_p_lldb__SBValueList);
}
result = (lldb::SBValueList *)new lldb::SBValueList((lldb::SBValueList const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBValueList(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBValueList__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBValueList__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBValueList'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBValueList::SBValueList()\n"
" lldb::SBValueList::SBValueList(lldb::SBValueList const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBValueList_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBValueList::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::IsValid",1,"lldb::SBValueList const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){
SWIG_fail_ptr("SBValueList_IsValid",1,SWIGTYPE_p_lldb__SBValueList);
}
result = (bool)((lldb::SBValueList const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValueList_Clear(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ;
SWIG_check_num_args("lldb::SBValueList::Clear",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::Clear",1,"lldb::SBValueList *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){
SWIG_fail_ptr("SBValueList_Clear",1,SWIGTYPE_p_lldb__SBValueList);
}
(arg1)->Clear();
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValueList_Append__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ;
lldb::SBValue *arg2 = 0 ;
SWIG_check_num_args("lldb::SBValueList::Append",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::Append",1,"lldb::SBValueList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValueList::Append",2,"lldb::SBValue const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){
SWIG_fail_ptr("SBValueList_Append",1,SWIGTYPE_p_lldb__SBValueList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBValue,0))){
SWIG_fail_ptr("SBValueList_Append",2,SWIGTYPE_p_lldb__SBValue);
}
(arg1)->Append((lldb::SBValue const &)*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValueList_Append__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ;
lldb::SBValueList *arg2 = 0 ;
SWIG_check_num_args("lldb::SBValueList::Append",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::Append",1,"lldb::SBValueList *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValueList::Append",2,"lldb::SBValueList const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){
SWIG_fail_ptr("SBValueList_Append",1,SWIGTYPE_p_lldb__SBValueList);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBValueList,0))){
SWIG_fail_ptr("SBValueList_Append",2,SWIGTYPE_p_lldb__SBValueList);
}
(arg1)->Append((lldb::SBValueList const &)*arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValueList_Append(lua_State* L) {
int argc;
int argv[3]={
1,2,3
};
argc = lua_gettop(L);
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValueList, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBValueList_Append__SWIG_0(L);
}
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValueList, 0)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
{
void *ptr;
if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_SBValueList_Append__SWIG_1(L);
}
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBValueList_Append'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBValueList::Append(lldb::SBValue const &)\n"
" lldb::SBValueList::Append(lldb::SBValueList const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBValueList_GetSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBValueList::GetSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::GetSize",1,"lldb::SBValueList const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){
SWIG_fail_ptr("SBValueList_GetSize",1,SWIGTYPE_p_lldb__SBValueList);
}
result = (uint32_t)((lldb::SBValueList const *)arg1)->GetSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValueList_GetValueAtIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ;
uint32_t arg2 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValueList::GetValueAtIndex",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::GetValueAtIndex",1,"lldb::SBValueList const *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValueList::GetValueAtIndex",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){
SWIG_fail_ptr("SBValueList_GetValueAtIndex",1,SWIGTYPE_p_lldb__SBValueList);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
result = ((lldb::SBValueList const *)arg1)->GetValueAtIndex(arg2);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValueList_FindValueObjectByUID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ;
lldb::user_id_t arg2 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValueList::FindValueObjectByUID",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::FindValueObjectByUID",1,"lldb::SBValueList *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValueList::FindValueObjectByUID",2,"lldb::user_id_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){
SWIG_fail_ptr("SBValueList_FindValueObjectByUID",1,SWIGTYPE_p_lldb__SBValueList);
}
arg2 = (lldb::user_id_t)lua_tointeger(L, 2);
result = (arg1)->FindValueObjectByUID(arg2);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValueList_GetFirstValueByName(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ;
char *arg2 = (char *) 0 ;
lldb::SBValue result;
SWIG_check_num_args("lldb::SBValueList::GetFirstValueByName",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::GetFirstValueByName",1,"lldb::SBValueList const *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValueList::GetFirstValueByName",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){
SWIG_fail_ptr("SBValueList_GetFirstValueByName",1,SWIGTYPE_p_lldb__SBValueList);
}
arg2 = (char *)lua_tostring(L, 2);
result = ((lldb::SBValueList const *)arg1)->GetFirstValueByName((char const *)arg2);
{
lldb::SBValue * resultptr = new lldb::SBValue((const lldb::SBValue &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBValueList___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBValueList::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::__str__",1,"lldb::SBValueList *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){
SWIG_fail_ptr("SBValueList___tostring",1,SWIGTYPE_p_lldb__SBValueList);
}
result = lldb_SBValueList___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBValueList(void *obj) {
lldb::SBValueList *arg1 = (lldb::SBValueList *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBValueList(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBValueList);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBValueList_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBValueList_methods[]= {
{ "IsValid", _wrap_SBValueList_IsValid},
{ "Clear", _wrap_SBValueList_Clear},
{ "Append", _wrap_SBValueList_Append},
{ "GetSize", _wrap_SBValueList_GetSize},
{ "GetValueAtIndex", _wrap_SBValueList_GetValueAtIndex},
{ "FindValueObjectByUID", _wrap_SBValueList_FindValueObjectByUID},
{ "GetFirstValueByName", _wrap_SBValueList_GetFirstValueByName},
{ "__tostring", _wrap_SBValueList___tostring},
{0,0}
};
static swig_lua_method swig_SBValueList_meta[] = {
{ "__tostring", _wrap_SBValueList___tostring},
{0,0}
};
static swig_lua_attribute swig_SBValueList_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBValueList_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBValueList_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBValueList_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBValueList_Sf_SwigStatic = {
"SBValueList",
swig_SBValueList_Sf_SwigStatic_methods,
swig_SBValueList_Sf_SwigStatic_attributes,
swig_SBValueList_Sf_SwigStatic_constants,
swig_SBValueList_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBValueList_bases[] = {0};
static const char *swig_SBValueList_base_names[] = {0};
static swig_lua_class _wrap_class_SBValueList = { "SBValueList", "SBValueList", &SWIGTYPE_p_lldb__SBValueList,_proxy__wrap_new_SBValueList, swig_delete_SBValueList, swig_SBValueList_methods, swig_SBValueList_attributes, &swig_SBValueList_Sf_SwigStatic, swig_SBValueList_meta, swig_SBValueList_bases, swig_SBValueList_base_names };
static int _wrap_new_SBVariablesOptions__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBVariablesOptions *result = 0 ;
SWIG_check_num_args("lldb::SBVariablesOptions::SBVariablesOptions",0,0)
result = (lldb::SBVariablesOptions *)new lldb::SBVariablesOptions();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBVariablesOptions,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBVariablesOptions__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBVariablesOptions *arg1 = 0 ;
lldb::SBVariablesOptions *result = 0 ;
SWIG_check_num_args("lldb::SBVariablesOptions::SBVariablesOptions",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::SBVariablesOptions",1,"lldb::SBVariablesOptions const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){
SWIG_fail_ptr("new_SBVariablesOptions",1,SWIGTYPE_p_lldb__SBVariablesOptions);
}
result = (lldb::SBVariablesOptions *)new lldb::SBVariablesOptions((lldb::SBVariablesOptions const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBVariablesOptions,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBVariablesOptions(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBVariablesOptions__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBVariablesOptions, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBVariablesOptions__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBVariablesOptions'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBVariablesOptions::SBVariablesOptions()\n"
" lldb::SBVariablesOptions::SBVariablesOptions(lldb::SBVariablesOptions const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBVariablesOptions_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBVariablesOptions::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::IsValid",1,"lldb::SBVariablesOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){
SWIG_fail_ptr("SBVariablesOptions_IsValid",1,SWIGTYPE_p_lldb__SBVariablesOptions);
}
result = (bool)((lldb::SBVariablesOptions const *)arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBVariablesOptions_GetIncludeArguments(lua_State* L) {
int SWIG_arg = 0;
lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBVariablesOptions::GetIncludeArguments",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::GetIncludeArguments",1,"lldb::SBVariablesOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){
SWIG_fail_ptr("SBVariablesOptions_GetIncludeArguments",1,SWIGTYPE_p_lldb__SBVariablesOptions);
}
result = (bool)((lldb::SBVariablesOptions const *)arg1)->GetIncludeArguments();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBVariablesOptions_SetIncludeArguments(lua_State* L) {
int SWIG_arg = 0;
lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBVariablesOptions::SetIncludeArguments",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeArguments",1,"lldb::SBVariablesOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeArguments",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){
SWIG_fail_ptr("SBVariablesOptions_SetIncludeArguments",1,SWIGTYPE_p_lldb__SBVariablesOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetIncludeArguments(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBVariablesOptions_GetIncludeRecognizedArguments(lua_State* L) {
int SWIG_arg = 0;
lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ;
lldb::SBTarget *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBVariablesOptions::GetIncludeRecognizedArguments",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::GetIncludeRecognizedArguments",1,"lldb::SBVariablesOptions const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBVariablesOptions::GetIncludeRecognizedArguments",2,"lldb::SBTarget const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){
SWIG_fail_ptr("SBVariablesOptions_GetIncludeRecognizedArguments",1,SWIGTYPE_p_lldb__SBVariablesOptions);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){
SWIG_fail_ptr("SBVariablesOptions_GetIncludeRecognizedArguments",2,SWIGTYPE_p_lldb__SBTarget);
}
result = (bool)((lldb::SBVariablesOptions const *)arg1)->GetIncludeRecognizedArguments((lldb::SBTarget const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBVariablesOptions_SetIncludeRecognizedArguments(lua_State* L) {
int SWIG_arg = 0;
lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBVariablesOptions::SetIncludeRecognizedArguments",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeRecognizedArguments",1,"lldb::SBVariablesOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeRecognizedArguments",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){
SWIG_fail_ptr("SBVariablesOptions_SetIncludeRecognizedArguments",1,SWIGTYPE_p_lldb__SBVariablesOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetIncludeRecognizedArguments(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBVariablesOptions_GetIncludeLocals(lua_State* L) {
int SWIG_arg = 0;
lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBVariablesOptions::GetIncludeLocals",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::GetIncludeLocals",1,"lldb::SBVariablesOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){
SWIG_fail_ptr("SBVariablesOptions_GetIncludeLocals",1,SWIGTYPE_p_lldb__SBVariablesOptions);
}
result = (bool)((lldb::SBVariablesOptions const *)arg1)->GetIncludeLocals();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBVariablesOptions_SetIncludeLocals(lua_State* L) {
int SWIG_arg = 0;
lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBVariablesOptions::SetIncludeLocals",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeLocals",1,"lldb::SBVariablesOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeLocals",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){
SWIG_fail_ptr("SBVariablesOptions_SetIncludeLocals",1,SWIGTYPE_p_lldb__SBVariablesOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetIncludeLocals(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBVariablesOptions_GetIncludeStatics(lua_State* L) {
int SWIG_arg = 0;
lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBVariablesOptions::GetIncludeStatics",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::GetIncludeStatics",1,"lldb::SBVariablesOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){
SWIG_fail_ptr("SBVariablesOptions_GetIncludeStatics",1,SWIGTYPE_p_lldb__SBVariablesOptions);
}
result = (bool)((lldb::SBVariablesOptions const *)arg1)->GetIncludeStatics();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBVariablesOptions_SetIncludeStatics(lua_State* L) {
int SWIG_arg = 0;
lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBVariablesOptions::SetIncludeStatics",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeStatics",1,"lldb::SBVariablesOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeStatics",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){
SWIG_fail_ptr("SBVariablesOptions_SetIncludeStatics",1,SWIGTYPE_p_lldb__SBVariablesOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetIncludeStatics(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBVariablesOptions_GetInScopeOnly(lua_State* L) {
int SWIG_arg = 0;
lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBVariablesOptions::GetInScopeOnly",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::GetInScopeOnly",1,"lldb::SBVariablesOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){
SWIG_fail_ptr("SBVariablesOptions_GetInScopeOnly",1,SWIGTYPE_p_lldb__SBVariablesOptions);
}
result = (bool)((lldb::SBVariablesOptions const *)arg1)->GetInScopeOnly();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBVariablesOptions_SetInScopeOnly(lua_State* L) {
int SWIG_arg = 0;
lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBVariablesOptions::SetInScopeOnly",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::SetInScopeOnly",1,"lldb::SBVariablesOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBVariablesOptions::SetInScopeOnly",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){
SWIG_fail_ptr("SBVariablesOptions_SetInScopeOnly",1,SWIGTYPE_p_lldb__SBVariablesOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetInScopeOnly(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBVariablesOptions_GetIncludeRuntimeSupportValues(lua_State* L) {
int SWIG_arg = 0;
lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBVariablesOptions::GetIncludeRuntimeSupportValues",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::GetIncludeRuntimeSupportValues",1,"lldb::SBVariablesOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){
SWIG_fail_ptr("SBVariablesOptions_GetIncludeRuntimeSupportValues",1,SWIGTYPE_p_lldb__SBVariablesOptions);
}
result = (bool)((lldb::SBVariablesOptions const *)arg1)->GetIncludeRuntimeSupportValues();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBVariablesOptions_SetIncludeRuntimeSupportValues(lua_State* L) {
int SWIG_arg = 0;
lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBVariablesOptions::SetIncludeRuntimeSupportValues",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeRuntimeSupportValues",1,"lldb::SBVariablesOptions *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeRuntimeSupportValues",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){
SWIG_fail_ptr("SBVariablesOptions_SetIncludeRuntimeSupportValues",1,SWIGTYPE_p_lldb__SBVariablesOptions);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetIncludeRuntimeSupportValues(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBVariablesOptions_GetUseDynamic(lua_State* L) {
int SWIG_arg = 0;
lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ;
lldb::DynamicValueType result;
SWIG_check_num_args("lldb::SBVariablesOptions::GetUseDynamic",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::GetUseDynamic",1,"lldb::SBVariablesOptions const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){
SWIG_fail_ptr("SBVariablesOptions_GetUseDynamic",1,SWIGTYPE_p_lldb__SBVariablesOptions);
}
result = (lldb::DynamicValueType)((lldb::SBVariablesOptions const *)arg1)->GetUseDynamic();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBVariablesOptions_SetUseDynamic(lua_State* L) {
int SWIG_arg = 0;
lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ;
lldb::DynamicValueType arg2 ;
SWIG_check_num_args("lldb::SBVariablesOptions::SetUseDynamic",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::SetUseDynamic",1,"lldb::SBVariablesOptions *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBVariablesOptions::SetUseDynamic",2,"lldb::DynamicValueType");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){
SWIG_fail_ptr("SBVariablesOptions_SetUseDynamic",1,SWIGTYPE_p_lldb__SBVariablesOptions);
}
arg2 = (lldb::DynamicValueType)lua_tointeger(L, 2);
(arg1)->SetUseDynamic(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBVariablesOptions(void *obj) {
lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBVariablesOptions(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBVariablesOptions);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBVariablesOptions_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBVariablesOptions_methods[]= {
{ "IsValid", _wrap_SBVariablesOptions_IsValid},
{ "GetIncludeArguments", _wrap_SBVariablesOptions_GetIncludeArguments},
{ "SetIncludeArguments", _wrap_SBVariablesOptions_SetIncludeArguments},
{ "GetIncludeRecognizedArguments", _wrap_SBVariablesOptions_GetIncludeRecognizedArguments},
{ "SetIncludeRecognizedArguments", _wrap_SBVariablesOptions_SetIncludeRecognizedArguments},
{ "GetIncludeLocals", _wrap_SBVariablesOptions_GetIncludeLocals},
{ "SetIncludeLocals", _wrap_SBVariablesOptions_SetIncludeLocals},
{ "GetIncludeStatics", _wrap_SBVariablesOptions_GetIncludeStatics},
{ "SetIncludeStatics", _wrap_SBVariablesOptions_SetIncludeStatics},
{ "GetInScopeOnly", _wrap_SBVariablesOptions_GetInScopeOnly},
{ "SetInScopeOnly", _wrap_SBVariablesOptions_SetInScopeOnly},
{ "GetIncludeRuntimeSupportValues", _wrap_SBVariablesOptions_GetIncludeRuntimeSupportValues},
{ "SetIncludeRuntimeSupportValues", _wrap_SBVariablesOptions_SetIncludeRuntimeSupportValues},
{ "GetUseDynamic", _wrap_SBVariablesOptions_GetUseDynamic},
{ "SetUseDynamic", _wrap_SBVariablesOptions_SetUseDynamic},
{0,0}
};
static swig_lua_method swig_SBVariablesOptions_meta[] = {
{0,0}
};
static swig_lua_attribute swig_SBVariablesOptions_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBVariablesOptions_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBVariablesOptions_Sf_SwigStatic_methods[]= {
{0,0}
};
static swig_lua_class* swig_SBVariablesOptions_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBVariablesOptions_Sf_SwigStatic = {
"SBVariablesOptions",
swig_SBVariablesOptions_Sf_SwigStatic_methods,
swig_SBVariablesOptions_Sf_SwigStatic_attributes,
swig_SBVariablesOptions_Sf_SwigStatic_constants,
swig_SBVariablesOptions_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBVariablesOptions_bases[] = {0};
static const char *swig_SBVariablesOptions_base_names[] = {0};
static swig_lua_class _wrap_class_SBVariablesOptions = { "SBVariablesOptions", "SBVariablesOptions", &SWIGTYPE_p_lldb__SBVariablesOptions,_proxy__wrap_new_SBVariablesOptions, swig_delete_SBVariablesOptions, swig_SBVariablesOptions_methods, swig_SBVariablesOptions_attributes, &swig_SBVariablesOptions_Sf_SwigStatic, swig_SBVariablesOptions_meta, swig_SBVariablesOptions_bases, swig_SBVariablesOptions_base_names };
static int _wrap_new_SBWatchpoint__SWIG_0(lua_State* L) {
int SWIG_arg = 0;
lldb::SBWatchpoint *result = 0 ;
SWIG_check_num_args("lldb::SBWatchpoint::SBWatchpoint",0,0)
result = (lldb::SBWatchpoint *)new lldb::SBWatchpoint();
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBWatchpoint,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBWatchpoint__SWIG_1(lua_State* L) {
int SWIG_arg = 0;
lldb::SBWatchpoint *arg1 = 0 ;
lldb::SBWatchpoint *result = 0 ;
SWIG_check_num_args("lldb::SBWatchpoint::SBWatchpoint",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::SBWatchpoint",1,"lldb::SBWatchpoint const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){
SWIG_fail_ptr("new_SBWatchpoint",1,SWIGTYPE_p_lldb__SBWatchpoint);
}
result = (lldb::SBWatchpoint *)new lldb::SBWatchpoint((lldb::SBWatchpoint const &)*arg1);
SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBWatchpoint,1); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_new_SBWatchpoint(lua_State* L) {
int argc;
int argv[2]={
1,2
};
argc = lua_gettop(L);
if (argc == 0) {
return _wrap_new_SBWatchpoint__SWIG_0(L);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBWatchpoint, SWIG_POINTER_NO_NULL)) {
_v = 0;
} else {
_v = 1;
}
}
if (_v) {
return _wrap_new_SBWatchpoint__SWIG_1(L);
}
}
SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBWatchpoint'\n"
" Possible C/C++ prototypes are:\n"
" lldb::SBWatchpoint::SBWatchpoint()\n"
" lldb::SBWatchpoint::SBWatchpoint(lldb::SBWatchpoint const &)\n");
lua_error(L);return 0;
}
static int _wrap_SBWatchpoint_IsValid(lua_State* L) {
int SWIG_arg = 0;
lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBWatchpoint::IsValid",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::IsValid",1,"lldb::SBWatchpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){
SWIG_fail_ptr("SBWatchpoint_IsValid",1,SWIGTYPE_p_lldb__SBWatchpoint);
}
result = (bool)(arg1)->IsValid();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBWatchpoint___eq(lua_State* L) {
int SWIG_arg = 0;
lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ;
lldb::SBWatchpoint *arg2 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBWatchpoint::operator ==",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::operator ==",1,"lldb::SBWatchpoint const *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBWatchpoint::operator ==",2,"lldb::SBWatchpoint const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){
SWIG_fail_ptr("SBWatchpoint___eq",1,SWIGTYPE_p_lldb__SBWatchpoint);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBWatchpoint,0))){
SWIG_fail_ptr("SBWatchpoint___eq",2,SWIGTYPE_p_lldb__SBWatchpoint);
}
result = (bool)((lldb::SBWatchpoint const *)arg1)->operator ==((lldb::SBWatchpoint const &)*arg2);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBWatchpoint_GetError(lua_State* L) {
int SWIG_arg = 0;
lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ;
lldb::SBError result;
SWIG_check_num_args("lldb::SBWatchpoint::GetError",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetError",1,"lldb::SBWatchpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){
SWIG_fail_ptr("SBWatchpoint_GetError",1,SWIGTYPE_p_lldb__SBWatchpoint);
}
result = (arg1)->GetError();
{
lldb::SBError * resultptr = new lldb::SBError((const lldb::SBError &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBWatchpoint_GetID(lua_State* L) {
int SWIG_arg = 0;
lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ;
lldb::watch_id_t result;
SWIG_check_num_args("lldb::SBWatchpoint::GetID",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetID",1,"lldb::SBWatchpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){
SWIG_fail_ptr("SBWatchpoint_GetID",1,SWIGTYPE_p_lldb__SBWatchpoint);
}
result = (lldb::watch_id_t)(arg1)->GetID();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBWatchpoint_GetHardwareIndex(lua_State* L) {
int SWIG_arg = 0;
lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ;
int32_t result;
SWIG_check_num_args("lldb::SBWatchpoint::GetHardwareIndex",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetHardwareIndex",1,"lldb::SBWatchpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){
SWIG_fail_ptr("SBWatchpoint_GetHardwareIndex",1,SWIGTYPE_p_lldb__SBWatchpoint);
}
result = (int32_t)(arg1)->GetHardwareIndex();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBWatchpoint_GetWatchAddress(lua_State* L) {
int SWIG_arg = 0;
lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ;
lldb::addr_t result;
SWIG_check_num_args("lldb::SBWatchpoint::GetWatchAddress",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetWatchAddress",1,"lldb::SBWatchpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){
SWIG_fail_ptr("SBWatchpoint_GetWatchAddress",1,SWIGTYPE_p_lldb__SBWatchpoint);
}
result = (lldb::addr_t)(arg1)->GetWatchAddress();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBWatchpoint_GetWatchSize(lua_State* L) {
int SWIG_arg = 0;
lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ;
size_t result;
SWIG_check_num_args("lldb::SBWatchpoint::GetWatchSize",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetWatchSize",1,"lldb::SBWatchpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){
SWIG_fail_ptr("SBWatchpoint_GetWatchSize",1,SWIGTYPE_p_lldb__SBWatchpoint);
}
result = (arg1)->GetWatchSize();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBWatchpoint_SetEnabled(lua_State* L) {
int SWIG_arg = 0;
lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ;
bool arg2 ;
SWIG_check_num_args("lldb::SBWatchpoint::SetEnabled",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::SetEnabled",1,"lldb::SBWatchpoint *");
if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBWatchpoint::SetEnabled",2,"bool");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){
SWIG_fail_ptr("SBWatchpoint_SetEnabled",1,SWIGTYPE_p_lldb__SBWatchpoint);
}
arg2 = (lua_toboolean(L, 2)!=0);
(arg1)->SetEnabled(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBWatchpoint_IsEnabled(lua_State* L) {
int SWIG_arg = 0;
lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ;
bool result;
SWIG_check_num_args("lldb::SBWatchpoint::IsEnabled",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::IsEnabled",1,"lldb::SBWatchpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){
SWIG_fail_ptr("SBWatchpoint_IsEnabled",1,SWIGTYPE_p_lldb__SBWatchpoint);
}
result = (bool)(arg1)->IsEnabled();
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBWatchpoint_GetHitCount(lua_State* L) {
int SWIG_arg = 0;
lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBWatchpoint::GetHitCount",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetHitCount",1,"lldb::SBWatchpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){
SWIG_fail_ptr("SBWatchpoint_GetHitCount",1,SWIGTYPE_p_lldb__SBWatchpoint);
}
result = (uint32_t)(arg1)->GetHitCount();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBWatchpoint_GetIgnoreCount(lua_State* L) {
int SWIG_arg = 0;
lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ;
uint32_t result;
SWIG_check_num_args("lldb::SBWatchpoint::GetIgnoreCount",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetIgnoreCount",1,"lldb::SBWatchpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){
SWIG_fail_ptr("SBWatchpoint_GetIgnoreCount",1,SWIGTYPE_p_lldb__SBWatchpoint);
}
result = (uint32_t)(arg1)->GetIgnoreCount();
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBWatchpoint_SetIgnoreCount(lua_State* L) {
int SWIG_arg = 0;
lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ;
uint32_t arg2 ;
SWIG_check_num_args("lldb::SBWatchpoint::SetIgnoreCount",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::SetIgnoreCount",1,"lldb::SBWatchpoint *");
if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBWatchpoint::SetIgnoreCount",2,"uint32_t");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){
SWIG_fail_ptr("SBWatchpoint_SetIgnoreCount",1,SWIGTYPE_p_lldb__SBWatchpoint);
}
arg2 = (uint32_t)lua_tointeger(L, 2);
(arg1)->SetIgnoreCount(arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBWatchpoint_GetCondition(lua_State* L) {
int SWIG_arg = 0;
lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ;
char *result = 0 ;
SWIG_check_num_args("lldb::SBWatchpoint::GetCondition",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetCondition",1,"lldb::SBWatchpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){
SWIG_fail_ptr("SBWatchpoint_GetCondition",1,SWIGTYPE_p_lldb__SBWatchpoint);
}
result = (char *)(arg1)->GetCondition();
lua_pushstring(L,(const char *)result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBWatchpoint_SetCondition(lua_State* L) {
int SWIG_arg = 0;
lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ;
char *arg2 = (char *) 0 ;
SWIG_check_num_args("lldb::SBWatchpoint::SetCondition",2,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::SetCondition",1,"lldb::SBWatchpoint *");
if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBWatchpoint::SetCondition",2,"char const *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){
SWIG_fail_ptr("SBWatchpoint_SetCondition",1,SWIGTYPE_p_lldb__SBWatchpoint);
}
arg2 = (char *)lua_tostring(L, 2);
(arg1)->SetCondition((char const *)arg2);
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBWatchpoint_GetDescription(lua_State* L) {
int SWIG_arg = 0;
lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ;
lldb::SBStream *arg2 = 0 ;
lldb::DescriptionLevel arg3 ;
bool result;
SWIG_check_num_args("lldb::SBWatchpoint::GetDescription",3,3)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetDescription",1,"lldb::SBWatchpoint *");
if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBWatchpoint::GetDescription",2,"lldb::SBStream &");
if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBWatchpoint::GetDescription",3,"lldb::DescriptionLevel");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){
SWIG_fail_ptr("SBWatchpoint_GetDescription",1,SWIGTYPE_p_lldb__SBWatchpoint);
}
if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){
SWIG_fail_ptr("SBWatchpoint_GetDescription",2,SWIGTYPE_p_lldb__SBStream);
}
arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3);
result = (bool)(arg1)->GetDescription(*arg2,arg3);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBWatchpoint_EventIsWatchpointEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
bool result;
SWIG_check_num_args("lldb::SBWatchpoint::EventIsWatchpointEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::EventIsWatchpointEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBWatchpoint_EventIsWatchpointEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (bool)lldb::SBWatchpoint::EventIsWatchpointEvent((lldb::SBEvent const &)*arg1);
lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBWatchpoint_GetWatchpointEventTypeFromEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
lldb::WatchpointEventType result;
SWIG_check_num_args("lldb::SBWatchpoint::GetWatchpointEventTypeFromEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetWatchpointEventTypeFromEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBWatchpoint_GetWatchpointEventTypeFromEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = (lldb::WatchpointEventType)lldb::SBWatchpoint::GetWatchpointEventTypeFromEvent((lldb::SBEvent const &)*arg1);
lua_pushinteger(L, (lua_Integer) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBWatchpoint_GetWatchpointFromEvent(lua_State* L) {
int SWIG_arg = 0;
lldb::SBEvent *arg1 = 0 ;
lldb::SBWatchpoint result;
SWIG_check_num_args("lldb::SBWatchpoint::GetWatchpointFromEvent",1,1)
if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetWatchpointFromEvent",1,"lldb::SBEvent const &");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){
SWIG_fail_ptr("SBWatchpoint_GetWatchpointFromEvent",1,SWIGTYPE_p_lldb__SBEvent);
}
result = lldb::SBWatchpoint::GetWatchpointFromEvent((lldb::SBEvent const &)*arg1);
{
lldb::SBWatchpoint * resultptr = new lldb::SBWatchpoint((const lldb::SBWatchpoint &) result);
SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBWatchpoint,1); SWIG_arg++;
}
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static int _wrap_SBWatchpoint___tostring(lua_State* L) {
int SWIG_arg = 0;
lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ;
std::string result;
SWIG_check_num_args("lldb::SBWatchpoint::__str__",1,1)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::__str__",1,"lldb::SBWatchpoint *");
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){
SWIG_fail_ptr("SBWatchpoint___tostring",1,SWIGTYPE_p_lldb__SBWatchpoint);
}
result = lldb_SBWatchpoint___str__(arg1);
lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
fail:
lua_error(L);
return SWIG_arg;
}
static void swig_delete_SBWatchpoint(void *obj) {
lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) obj;
delete arg1;
}
static int _proxy__wrap_new_SBWatchpoint(lua_State *L) {
assert(lua_istable(L,1));
lua_pushcfunction(L,_wrap_new_SBWatchpoint);
assert(!lua_isnil(L,-1));
lua_replace(L,1); /* replace our table with real constructor */
lua_call(L,lua_gettop(L)-1,1);
return 1;
}
static swig_lua_attribute swig_SBWatchpoint_attributes[] = {
{0,0,0}
};
static swig_lua_method swig_SBWatchpoint_methods[]= {
{ "IsValid", _wrap_SBWatchpoint_IsValid},
{ "__eq", _wrap_SBWatchpoint___eq},
{ "GetError", _wrap_SBWatchpoint_GetError},
{ "GetID", _wrap_SBWatchpoint_GetID},
{ "GetHardwareIndex", _wrap_SBWatchpoint_GetHardwareIndex},
{ "GetWatchAddress", _wrap_SBWatchpoint_GetWatchAddress},
{ "GetWatchSize", _wrap_SBWatchpoint_GetWatchSize},
{ "SetEnabled", _wrap_SBWatchpoint_SetEnabled},
{ "IsEnabled", _wrap_SBWatchpoint_IsEnabled},
{ "GetHitCount", _wrap_SBWatchpoint_GetHitCount},
{ "GetIgnoreCount", _wrap_SBWatchpoint_GetIgnoreCount},
{ "SetIgnoreCount", _wrap_SBWatchpoint_SetIgnoreCount},
{ "GetCondition", _wrap_SBWatchpoint_GetCondition},
{ "SetCondition", _wrap_SBWatchpoint_SetCondition},
{ "GetDescription", _wrap_SBWatchpoint_GetDescription},
{ "__tostring", _wrap_SBWatchpoint___tostring},
{0,0}
};
static swig_lua_method swig_SBWatchpoint_meta[] = {
{ "__eq", _wrap_SBWatchpoint___eq},
{ "__tostring", _wrap_SBWatchpoint___tostring},
{0,0}
};
static swig_lua_attribute swig_SBWatchpoint_Sf_SwigStatic_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SBWatchpoint_Sf_SwigStatic_constants[]= {
{0,0,0,0,0,0}
};
static swig_lua_method swig_SBWatchpoint_Sf_SwigStatic_methods[]= {
{ "EventIsWatchpointEvent", _wrap_SBWatchpoint_EventIsWatchpointEvent},
{ "GetWatchpointEventTypeFromEvent", _wrap_SBWatchpoint_GetWatchpointEventTypeFromEvent},
{ "GetWatchpointFromEvent", _wrap_SBWatchpoint_GetWatchpointFromEvent},
{0,0}
};
static swig_lua_class* swig_SBWatchpoint_Sf_SwigStatic_classes[]= {
0
};
static swig_lua_namespace swig_SBWatchpoint_Sf_SwigStatic = {
"SBWatchpoint",
swig_SBWatchpoint_Sf_SwigStatic_methods,
swig_SBWatchpoint_Sf_SwigStatic_attributes,
swig_SBWatchpoint_Sf_SwigStatic_constants,
swig_SBWatchpoint_Sf_SwigStatic_classes,
0
};
static swig_lua_class *swig_SBWatchpoint_bases[] = {0};
static const char *swig_SBWatchpoint_base_names[] = {0};
static swig_lua_class _wrap_class_SBWatchpoint = { "SBWatchpoint", "SBWatchpoint", &SWIGTYPE_p_lldb__SBWatchpoint,_proxy__wrap_new_SBWatchpoint, swig_delete_SBWatchpoint, swig_SBWatchpoint_methods, swig_SBWatchpoint_attributes, &swig_SBWatchpoint_Sf_SwigStatic, swig_SBWatchpoint_meta, swig_SBWatchpoint_bases, swig_SBWatchpoint_base_names };
static swig_lua_attribute swig_SwigModule_attributes[] = {
{0,0,0}
};
static swig_lua_const_info swig_SwigModule_constants[]= {
{SWIG_LUA_CONSTTAB_INT("INT32_MAX", 2147483647)},
{SWIG_LUA_CONSTTAB_INT("UINT32_MAX", 4294967295U)},
{SWIG_LUA_CONSTTAB_STRING("UINT64_MAX", "18446744073709551615ULL")},
{SWIG_LUA_CONSTTAB_INT("LLDB_GENERIC_ERROR", 4294967295U)},
{SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_BREAK_ID", 0)},
{SWIG_LUA_CONSTTAB_INT("LLDB_DEFAULT_BREAK_SIZE", 0)},
{SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_WATCH_ID", 0)},
{SWIG_LUA_CONSTTAB_INT("LLDB_WATCH_TYPE_READ", (1u << 0))},
{SWIG_LUA_CONSTTAB_INT("LLDB_WATCH_TYPE_WRITE", (1u << 1))},
{SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_PC", 0)},
{SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_SP", 1)},
{SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_FP", 2)},
{SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_RA", 3)},
{SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_FLAGS", 4)},
{SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_ARG1", 5)},
{SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_ARG2", 6)},
{SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_ARG3", 7)},
{SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_ARG4", 8)},
{SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_ARG5", 9)},
{SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_ARG6", 10)},
{SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_ARG7", 11)},
{SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_ARG8", 12)},
{SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_STOP_ID", 0)},
{SWIG_LUA_CONSTTAB_STRING("LLDB_INVALID_ADDRESS", "18446744073709551615ULL")},
{SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_INDEX32", 4294967295U)},
{SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_IVAR_OFFSET", 4294967295U)},
{SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_IMAGE_TOKEN", 4294967295U)},
{SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_MODULE_VERSION", 4294967295U)},
{SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_REGNUM", 4294967295U)},
{SWIG_LUA_CONSTTAB_STRING("LLDB_INVALID_UID", "18446744073709551615ULL")},
{SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_PROCESS_ID", 0)},
{SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_THREAD_ID", 0)},
{SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_FRAME_ID", 4294967295U)},
{SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_SIGNAL_NUMBER", 2147483647)},
{SWIG_LUA_CONSTTAB_STRING("LLDB_INVALID_OFFSET", "18446744073709551615ULL")},
{SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_LINE_NUMBER", 4294967295U)},
{SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_COLUMN_NUMBER", 0)},
{SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_QUEUE_ID", 0)},
{SWIG_LUA_CONSTTAB_STRING("LLDB_ARCH_DEFAULT", "systemArch")},
{SWIG_LUA_CONSTTAB_STRING("LLDB_ARCH_DEFAULT_32BIT", "systemArch32")},
{SWIG_LUA_CONSTTAB_STRING("LLDB_ARCH_DEFAULT_64BIT", "systemArch64")},
{SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_CPUTYPE", (0xFFFFFFFEu))},
{SWIG_LUA_CONSTTAB_INT("LLDB_MAX_NUM_OPTION_SETS", 32)},
{SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_ALL", 0xFFFFFFFFU)},
{SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_1", (1U << 0))},
{SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_2", (1U << 1))},
{SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_3", (1U << 2))},
{SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_4", (1U << 3))},
{SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_5", (1U << 4))},
{SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_6", (1U << 5))},
{SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_7", (1U << 6))},
{SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_8", (1U << 7))},
{SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_9", (1U << 8))},
{SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_10", (1U << 9))},
{SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_11", (1U << 10))},
{SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_12", (1U << 11))},
{SWIG_LUA_CONSTTAB_INT("eStateInvalid", lldb::eStateInvalid)},
{SWIG_LUA_CONSTTAB_INT("eStateUnloaded", lldb::eStateUnloaded)},
{SWIG_LUA_CONSTTAB_INT("eStateConnected", lldb::eStateConnected)},
{SWIG_LUA_CONSTTAB_INT("eStateAttaching", lldb::eStateAttaching)},
{SWIG_LUA_CONSTTAB_INT("eStateLaunching", lldb::eStateLaunching)},
{SWIG_LUA_CONSTTAB_INT("eStateStopped", lldb::eStateStopped)},
{SWIG_LUA_CONSTTAB_INT("eStateRunning", lldb::eStateRunning)},
{SWIG_LUA_CONSTTAB_INT("eStateStepping", lldb::eStateStepping)},
{SWIG_LUA_CONSTTAB_INT("eStateCrashed", lldb::eStateCrashed)},
{SWIG_LUA_CONSTTAB_INT("eStateDetached", lldb::eStateDetached)},
{SWIG_LUA_CONSTTAB_INT("eStateExited", lldb::eStateExited)},
{SWIG_LUA_CONSTTAB_INT("eStateSuspended", lldb::eStateSuspended)},
{SWIG_LUA_CONSTTAB_INT("kLastStateType", lldb::kLastStateType)},
{SWIG_LUA_CONSTTAB_INT("eLaunchFlagNone", lldb::eLaunchFlagNone)},
{SWIG_LUA_CONSTTAB_INT("eLaunchFlagExec", lldb::eLaunchFlagExec)},
{SWIG_LUA_CONSTTAB_INT("eLaunchFlagDebug", lldb::eLaunchFlagDebug)},
{SWIG_LUA_CONSTTAB_INT("eLaunchFlagStopAtEntry", lldb::eLaunchFlagStopAtEntry)},
{SWIG_LUA_CONSTTAB_INT("eLaunchFlagDisableASLR", lldb::eLaunchFlagDisableASLR)},
{SWIG_LUA_CONSTTAB_INT("eLaunchFlagDisableSTDIO", lldb::eLaunchFlagDisableSTDIO)},
{SWIG_LUA_CONSTTAB_INT("eLaunchFlagLaunchInTTY", lldb::eLaunchFlagLaunchInTTY)},
{SWIG_LUA_CONSTTAB_INT("eLaunchFlagLaunchInShell", lldb::eLaunchFlagLaunchInShell)},
{SWIG_LUA_CONSTTAB_INT("eLaunchFlagLaunchInSeparateProcessGroup", lldb::eLaunchFlagLaunchInSeparateProcessGroup)},
{SWIG_LUA_CONSTTAB_INT("eLaunchFlagDontSetExitStatus", lldb::eLaunchFlagDontSetExitStatus)},
{SWIG_LUA_CONSTTAB_INT("eLaunchFlagDetachOnError", lldb::eLaunchFlagDetachOnError)},
{SWIG_LUA_CONSTTAB_INT("eLaunchFlagShellExpandArguments", lldb::eLaunchFlagShellExpandArguments)},
{SWIG_LUA_CONSTTAB_INT("eLaunchFlagCloseTTYOnExit", lldb::eLaunchFlagCloseTTYOnExit)},
{SWIG_LUA_CONSTTAB_INT("eLaunchFlagInheritTCCFromParent", lldb::eLaunchFlagInheritTCCFromParent)},
{SWIG_LUA_CONSTTAB_INT("eOnlyThisThread", lldb::eOnlyThisThread)},
{SWIG_LUA_CONSTTAB_INT("eAllThreads", lldb::eAllThreads)},
{SWIG_LUA_CONSTTAB_INT("eOnlyDuringStepping", lldb::eOnlyDuringStepping)},
{SWIG_LUA_CONSTTAB_INT("eByteOrderInvalid", lldb::eByteOrderInvalid)},
{SWIG_LUA_CONSTTAB_INT("eByteOrderBig", lldb::eByteOrderBig)},
{SWIG_LUA_CONSTTAB_INT("eByteOrderPDP", lldb::eByteOrderPDP)},
{SWIG_LUA_CONSTTAB_INT("eByteOrderLittle", lldb::eByteOrderLittle)},
{SWIG_LUA_CONSTTAB_INT("eEncodingInvalid", lldb::eEncodingInvalid)},
{SWIG_LUA_CONSTTAB_INT("eEncodingUint", lldb::eEncodingUint)},
{SWIG_LUA_CONSTTAB_INT("eEncodingSint", lldb::eEncodingSint)},
{SWIG_LUA_CONSTTAB_INT("eEncodingIEEE754", lldb::eEncodingIEEE754)},
{SWIG_LUA_CONSTTAB_INT("eEncodingVector", lldb::eEncodingVector)},
{SWIG_LUA_CONSTTAB_INT("eFormatDefault", lldb::eFormatDefault)},
{SWIG_LUA_CONSTTAB_INT("eFormatInvalid", lldb::eFormatInvalid)},
{SWIG_LUA_CONSTTAB_INT("eFormatBoolean", lldb::eFormatBoolean)},
{SWIG_LUA_CONSTTAB_INT("eFormatBinary", lldb::eFormatBinary)},
{SWIG_LUA_CONSTTAB_INT("eFormatBytes", lldb::eFormatBytes)},
{SWIG_LUA_CONSTTAB_INT("eFormatBytesWithASCII", lldb::eFormatBytesWithASCII)},
{SWIG_LUA_CONSTTAB_INT("eFormatChar", lldb::eFormatChar)},
{SWIG_LUA_CONSTTAB_INT("eFormatCharPrintable", lldb::eFormatCharPrintable)},
{SWIG_LUA_CONSTTAB_INT("eFormatComplex", lldb::eFormatComplex)},
{SWIG_LUA_CONSTTAB_INT("eFormatComplexFloat", lldb::eFormatComplexFloat)},
{SWIG_LUA_CONSTTAB_INT("eFormatCString", lldb::eFormatCString)},
{SWIG_LUA_CONSTTAB_INT("eFormatDecimal", lldb::eFormatDecimal)},
{SWIG_LUA_CONSTTAB_INT("eFormatEnum", lldb::eFormatEnum)},
{SWIG_LUA_CONSTTAB_INT("eFormatHex", lldb::eFormatHex)},
{SWIG_LUA_CONSTTAB_INT("eFormatHexUppercase", lldb::eFormatHexUppercase)},
{SWIG_LUA_CONSTTAB_INT("eFormatFloat", lldb::eFormatFloat)},
{SWIG_LUA_CONSTTAB_INT("eFormatOctal", lldb::eFormatOctal)},
{SWIG_LUA_CONSTTAB_INT("eFormatOSType", lldb::eFormatOSType)},
{SWIG_LUA_CONSTTAB_INT("eFormatUnicode16", lldb::eFormatUnicode16)},
{SWIG_LUA_CONSTTAB_INT("eFormatUnicode32", lldb::eFormatUnicode32)},
{SWIG_LUA_CONSTTAB_INT("eFormatUnsigned", lldb::eFormatUnsigned)},
{SWIG_LUA_CONSTTAB_INT("eFormatPointer", lldb::eFormatPointer)},
{SWIG_LUA_CONSTTAB_INT("eFormatVectorOfChar", lldb::eFormatVectorOfChar)},
{SWIG_LUA_CONSTTAB_INT("eFormatVectorOfSInt8", lldb::eFormatVectorOfSInt8)},
{SWIG_LUA_CONSTTAB_INT("eFormatVectorOfUInt8", lldb::eFormatVectorOfUInt8)},
{SWIG_LUA_CONSTTAB_INT("eFormatVectorOfSInt16", lldb::eFormatVectorOfSInt16)},
{SWIG_LUA_CONSTTAB_INT("eFormatVectorOfUInt16", lldb::eFormatVectorOfUInt16)},
{SWIG_LUA_CONSTTAB_INT("eFormatVectorOfSInt32", lldb::eFormatVectorOfSInt32)},
{SWIG_LUA_CONSTTAB_INT("eFormatVectorOfUInt32", lldb::eFormatVectorOfUInt32)},
{SWIG_LUA_CONSTTAB_INT("eFormatVectorOfSInt64", lldb::eFormatVectorOfSInt64)},
{SWIG_LUA_CONSTTAB_INT("eFormatVectorOfUInt64", lldb::eFormatVectorOfUInt64)},
{SWIG_LUA_CONSTTAB_INT("eFormatVectorOfFloat16", lldb::eFormatVectorOfFloat16)},
{SWIG_LUA_CONSTTAB_INT("eFormatVectorOfFloat32", lldb::eFormatVectorOfFloat32)},
{SWIG_LUA_CONSTTAB_INT("eFormatVectorOfFloat64", lldb::eFormatVectorOfFloat64)},
{SWIG_LUA_CONSTTAB_INT("eFormatVectorOfUInt128", lldb::eFormatVectorOfUInt128)},
{SWIG_LUA_CONSTTAB_INT("eFormatComplexInteger", lldb::eFormatComplexInteger)},
{SWIG_LUA_CONSTTAB_INT("eFormatCharArray", lldb::eFormatCharArray)},
{SWIG_LUA_CONSTTAB_INT("eFormatAddressInfo", lldb::eFormatAddressInfo)},
{SWIG_LUA_CONSTTAB_INT("eFormatHexFloat", lldb::eFormatHexFloat)},
{SWIG_LUA_CONSTTAB_INT("eFormatInstruction", lldb::eFormatInstruction)},
{SWIG_LUA_CONSTTAB_INT("eFormatVoid", lldb::eFormatVoid)},
{SWIG_LUA_CONSTTAB_INT("eFormatUnicode8", lldb::eFormatUnicode8)},
{SWIG_LUA_CONSTTAB_INT("kNumFormats", lldb::kNumFormats)},
{SWIG_LUA_CONSTTAB_INT("eDescriptionLevelBrief", lldb::eDescriptionLevelBrief)},
{SWIG_LUA_CONSTTAB_INT("eDescriptionLevelFull", lldb::eDescriptionLevelFull)},
{SWIG_LUA_CONSTTAB_INT("eDescriptionLevelVerbose", lldb::eDescriptionLevelVerbose)},
{SWIG_LUA_CONSTTAB_INT("eDescriptionLevelInitial", lldb::eDescriptionLevelInitial)},
{SWIG_LUA_CONSTTAB_INT("kNumDescriptionLevels", lldb::kNumDescriptionLevels)},
{SWIG_LUA_CONSTTAB_INT("eScriptLanguageNone", lldb::eScriptLanguageNone)},
{SWIG_LUA_CONSTTAB_INT("eScriptLanguagePython", lldb::eScriptLanguagePython)},
{SWIG_LUA_CONSTTAB_INT("eScriptLanguageLua", lldb::eScriptLanguageLua)},
{SWIG_LUA_CONSTTAB_INT("eScriptLanguageUnknown", lldb::eScriptLanguageUnknown)},
{SWIG_LUA_CONSTTAB_INT("eScriptLanguageDefault", lldb::eScriptLanguageDefault)},
{SWIG_LUA_CONSTTAB_INT("eRegisterKindEHFrame", lldb::eRegisterKindEHFrame)},
{SWIG_LUA_CONSTTAB_INT("eRegisterKindDWARF", lldb::eRegisterKindDWARF)},
{SWIG_LUA_CONSTTAB_INT("eRegisterKindGeneric", lldb::eRegisterKindGeneric)},
{SWIG_LUA_CONSTTAB_INT("eRegisterKindProcessPlugin", lldb::eRegisterKindProcessPlugin)},
{SWIG_LUA_CONSTTAB_INT("eRegisterKindLLDB", lldb::eRegisterKindLLDB)},
{SWIG_LUA_CONSTTAB_INT("kNumRegisterKinds", lldb::kNumRegisterKinds)},
{SWIG_LUA_CONSTTAB_INT("eStopReasonInvalid", lldb::eStopReasonInvalid)},
{SWIG_LUA_CONSTTAB_INT("eStopReasonNone", lldb::eStopReasonNone)},
{SWIG_LUA_CONSTTAB_INT("eStopReasonTrace", lldb::eStopReasonTrace)},
{SWIG_LUA_CONSTTAB_INT("eStopReasonBreakpoint", lldb::eStopReasonBreakpoint)},
{SWIG_LUA_CONSTTAB_INT("eStopReasonWatchpoint", lldb::eStopReasonWatchpoint)},
{SWIG_LUA_CONSTTAB_INT("eStopReasonSignal", lldb::eStopReasonSignal)},
{SWIG_LUA_CONSTTAB_INT("eStopReasonException", lldb::eStopReasonException)},
{SWIG_LUA_CONSTTAB_INT("eStopReasonExec", lldb::eStopReasonExec)},
{SWIG_LUA_CONSTTAB_INT("eStopReasonPlanComplete", lldb::eStopReasonPlanComplete)},
{SWIG_LUA_CONSTTAB_INT("eStopReasonThreadExiting", lldb::eStopReasonThreadExiting)},
{SWIG_LUA_CONSTTAB_INT("eStopReasonInstrumentation", lldb::eStopReasonInstrumentation)},
{SWIG_LUA_CONSTTAB_INT("eStopReasonProcessorTrace", lldb::eStopReasonProcessorTrace)},
{SWIG_LUA_CONSTTAB_INT("eStopReasonFork", lldb::eStopReasonFork)},
{SWIG_LUA_CONSTTAB_INT("eStopReasonVFork", lldb::eStopReasonVFork)},
{SWIG_LUA_CONSTTAB_INT("eStopReasonVForkDone", lldb::eStopReasonVForkDone)},
{SWIG_LUA_CONSTTAB_INT("eReturnStatusInvalid", lldb::eReturnStatusInvalid)},
{SWIG_LUA_CONSTTAB_INT("eReturnStatusSuccessFinishNoResult", lldb::eReturnStatusSuccessFinishNoResult)},
{SWIG_LUA_CONSTTAB_INT("eReturnStatusSuccessFinishResult", lldb::eReturnStatusSuccessFinishResult)},
{SWIG_LUA_CONSTTAB_INT("eReturnStatusSuccessContinuingNoResult", lldb::eReturnStatusSuccessContinuingNoResult)},
{SWIG_LUA_CONSTTAB_INT("eReturnStatusSuccessContinuingResult", lldb::eReturnStatusSuccessContinuingResult)},
{SWIG_LUA_CONSTTAB_INT("eReturnStatusStarted", lldb::eReturnStatusStarted)},
{SWIG_LUA_CONSTTAB_INT("eReturnStatusFailed", lldb::eReturnStatusFailed)},
{SWIG_LUA_CONSTTAB_INT("eReturnStatusQuit", lldb::eReturnStatusQuit)},
{SWIG_LUA_CONSTTAB_INT("eExpressionCompleted", lldb::eExpressionCompleted)},
{SWIG_LUA_CONSTTAB_INT("eExpressionSetupError", lldb::eExpressionSetupError)},
{SWIG_LUA_CONSTTAB_INT("eExpressionParseError", lldb::eExpressionParseError)},
{SWIG_LUA_CONSTTAB_INT("eExpressionDiscarded", lldb::eExpressionDiscarded)},
{SWIG_LUA_CONSTTAB_INT("eExpressionInterrupted", lldb::eExpressionInterrupted)},
{SWIG_LUA_CONSTTAB_INT("eExpressionHitBreakpoint", lldb::eExpressionHitBreakpoint)},
{SWIG_LUA_CONSTTAB_INT("eExpressionTimedOut", lldb::eExpressionTimedOut)},
{SWIG_LUA_CONSTTAB_INT("eExpressionResultUnavailable", lldb::eExpressionResultUnavailable)},
{SWIG_LUA_CONSTTAB_INT("eExpressionStoppedForDebug", lldb::eExpressionStoppedForDebug)},
{SWIG_LUA_CONSTTAB_INT("eExpressionThreadVanished", lldb::eExpressionThreadVanished)},
{SWIG_LUA_CONSTTAB_INT("eSearchDepthInvalid", lldb::eSearchDepthInvalid)},
{SWIG_LUA_CONSTTAB_INT("eSearchDepthTarget", lldb::eSearchDepthTarget)},
{SWIG_LUA_CONSTTAB_INT("eSearchDepthModule", lldb::eSearchDepthModule)},
{SWIG_LUA_CONSTTAB_INT("eSearchDepthCompUnit", lldb::eSearchDepthCompUnit)},
{SWIG_LUA_CONSTTAB_INT("eSearchDepthFunction", lldb::eSearchDepthFunction)},
{SWIG_LUA_CONSTTAB_INT("eSearchDepthBlock", lldb::eSearchDepthBlock)},
{SWIG_LUA_CONSTTAB_INT("eSearchDepthAddress", lldb::eSearchDepthAddress)},
{SWIG_LUA_CONSTTAB_INT("kLastSearchDepthKind", lldb::kLastSearchDepthKind)},
{SWIG_LUA_CONSTTAB_INT("eConnectionStatusSuccess", lldb::eConnectionStatusSuccess)},
{SWIG_LUA_CONSTTAB_INT("eConnectionStatusEndOfFile", lldb::eConnectionStatusEndOfFile)},
{SWIG_LUA_CONSTTAB_INT("eConnectionStatusError", lldb::eConnectionStatusError)},
{SWIG_LUA_CONSTTAB_INT("eConnectionStatusTimedOut", lldb::eConnectionStatusTimedOut)},
{SWIG_LUA_CONSTTAB_INT("eConnectionStatusNoConnection", lldb::eConnectionStatusNoConnection)},
{SWIG_LUA_CONSTTAB_INT("eConnectionStatusLostConnection", lldb::eConnectionStatusLostConnection)},
{SWIG_LUA_CONSTTAB_INT("eConnectionStatusInterrupted", lldb::eConnectionStatusInterrupted)},
{SWIG_LUA_CONSTTAB_INT("eErrorTypeInvalid", lldb::eErrorTypeInvalid)},
{SWIG_LUA_CONSTTAB_INT("eErrorTypeGeneric", lldb::eErrorTypeGeneric)},
{SWIG_LUA_CONSTTAB_INT("eErrorTypeMachKernel", lldb::eErrorTypeMachKernel)},
{SWIG_LUA_CONSTTAB_INT("eErrorTypePOSIX", lldb::eErrorTypePOSIX)},
{SWIG_LUA_CONSTTAB_INT("eErrorTypeExpression", lldb::eErrorTypeExpression)},
{SWIG_LUA_CONSTTAB_INT("eErrorTypeWin32", lldb::eErrorTypeWin32)},
{SWIG_LUA_CONSTTAB_INT("eValueTypeInvalid", lldb::eValueTypeInvalid)},
{SWIG_LUA_CONSTTAB_INT("eValueTypeVariableGlobal", lldb::eValueTypeVariableGlobal)},
{SWIG_LUA_CONSTTAB_INT("eValueTypeVariableStatic", lldb::eValueTypeVariableStatic)},
{SWIG_LUA_CONSTTAB_INT("eValueTypeVariableArgument", lldb::eValueTypeVariableArgument)},
{SWIG_LUA_CONSTTAB_INT("eValueTypeVariableLocal", lldb::eValueTypeVariableLocal)},
{SWIG_LUA_CONSTTAB_INT("eValueTypeRegister", lldb::eValueTypeRegister)},
{SWIG_LUA_CONSTTAB_INT("eValueTypeRegisterSet", lldb::eValueTypeRegisterSet)},
{SWIG_LUA_CONSTTAB_INT("eValueTypeConstResult", lldb::eValueTypeConstResult)},
{SWIG_LUA_CONSTTAB_INT("eValueTypeVariableThreadLocal", lldb::eValueTypeVariableThreadLocal)},
{SWIG_LUA_CONSTTAB_INT("eInputReaderGranularityInvalid", lldb::eInputReaderGranularityInvalid)},
{SWIG_LUA_CONSTTAB_INT("eInputReaderGranularityByte", lldb::eInputReaderGranularityByte)},
{SWIG_LUA_CONSTTAB_INT("eInputReaderGranularityWord", lldb::eInputReaderGranularityWord)},
{SWIG_LUA_CONSTTAB_INT("eInputReaderGranularityLine", lldb::eInputReaderGranularityLine)},
{SWIG_LUA_CONSTTAB_INT("eInputReaderGranularityAll", lldb::eInputReaderGranularityAll)},
{SWIG_LUA_CONSTTAB_INT("eSymbolContextTarget", lldb::eSymbolContextTarget)},
{SWIG_LUA_CONSTTAB_INT("eSymbolContextModule", lldb::eSymbolContextModule)},
{SWIG_LUA_CONSTTAB_INT("eSymbolContextCompUnit", lldb::eSymbolContextCompUnit)},
{SWIG_LUA_CONSTTAB_INT("eSymbolContextFunction", lldb::eSymbolContextFunction)},
{SWIG_LUA_CONSTTAB_INT("eSymbolContextBlock", lldb::eSymbolContextBlock)},
{SWIG_LUA_CONSTTAB_INT("eSymbolContextLineEntry", lldb::eSymbolContextLineEntry)},
{SWIG_LUA_CONSTTAB_INT("eSymbolContextSymbol", lldb::eSymbolContextSymbol)},
{SWIG_LUA_CONSTTAB_INT("eSymbolContextEverything", lldb::eSymbolContextEverything)},
{SWIG_LUA_CONSTTAB_INT("eSymbolContextVariable", lldb::eSymbolContextVariable)},
{SWIG_LUA_CONSTTAB_INT("ePermissionsWritable", lldb::ePermissionsWritable)},
{SWIG_LUA_CONSTTAB_INT("ePermissionsReadable", lldb::ePermissionsReadable)},
{SWIG_LUA_CONSTTAB_INT("ePermissionsExecutable", lldb::ePermissionsExecutable)},
{SWIG_LUA_CONSTTAB_INT("eInputReaderActivate", lldb::eInputReaderActivate)},
{SWIG_LUA_CONSTTAB_INT("eInputReaderAsynchronousOutputWritten", lldb::eInputReaderAsynchronousOutputWritten)},
{SWIG_LUA_CONSTTAB_INT("eInputReaderReactivate", lldb::eInputReaderReactivate)},
{SWIG_LUA_CONSTTAB_INT("eInputReaderDeactivate", lldb::eInputReaderDeactivate)},
{SWIG_LUA_CONSTTAB_INT("eInputReaderGotToken", lldb::eInputReaderGotToken)},
{SWIG_LUA_CONSTTAB_INT("eInputReaderInterrupt", lldb::eInputReaderInterrupt)},
{SWIG_LUA_CONSTTAB_INT("eInputReaderEndOfFile", lldb::eInputReaderEndOfFile)},
{SWIG_LUA_CONSTTAB_INT("eInputReaderDone", lldb::eInputReaderDone)},
{SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeInvalidType", lldb::eBreakpointEventTypeInvalidType)},
{SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeAdded", lldb::eBreakpointEventTypeAdded)},
{SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeRemoved", lldb::eBreakpointEventTypeRemoved)},
{SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeLocationsAdded", lldb::eBreakpointEventTypeLocationsAdded)},
{SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeLocationsRemoved", lldb::eBreakpointEventTypeLocationsRemoved)},
{SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeLocationsResolved", lldb::eBreakpointEventTypeLocationsResolved)},
{SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeEnabled", lldb::eBreakpointEventTypeEnabled)},
{SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeDisabled", lldb::eBreakpointEventTypeDisabled)},
{SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeCommandChanged", lldb::eBreakpointEventTypeCommandChanged)},
{SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeConditionChanged", lldb::eBreakpointEventTypeConditionChanged)},
{SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeIgnoreChanged", lldb::eBreakpointEventTypeIgnoreChanged)},
{SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeThreadChanged", lldb::eBreakpointEventTypeThreadChanged)},
{SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeAutoContinueChanged", lldb::eBreakpointEventTypeAutoContinueChanged)},
{SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeInvalidType", lldb::eWatchpointEventTypeInvalidType)},
{SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeAdded", lldb::eWatchpointEventTypeAdded)},
{SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeRemoved", lldb::eWatchpointEventTypeRemoved)},
{SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeEnabled", lldb::eWatchpointEventTypeEnabled)},
{SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeDisabled", lldb::eWatchpointEventTypeDisabled)},
{SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeCommandChanged", lldb::eWatchpointEventTypeCommandChanged)},
{SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeConditionChanged", lldb::eWatchpointEventTypeConditionChanged)},
{SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeIgnoreChanged", lldb::eWatchpointEventTypeIgnoreChanged)},
{SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeThreadChanged", lldb::eWatchpointEventTypeThreadChanged)},
{SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeTypeChanged", lldb::eWatchpointEventTypeTypeChanged)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeUnknown", lldb::eLanguageTypeUnknown)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeC89", lldb::eLanguageTypeC89)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeC", lldb::eLanguageTypeC)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeAda83", lldb::eLanguageTypeAda83)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeC_plus_plus", lldb::eLanguageTypeC_plus_plus)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeCobol74", lldb::eLanguageTypeCobol74)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeCobol85", lldb::eLanguageTypeCobol85)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeFortran77", lldb::eLanguageTypeFortran77)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeFortran90", lldb::eLanguageTypeFortran90)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypePascal83", lldb::eLanguageTypePascal83)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeModula2", lldb::eLanguageTypeModula2)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeJava", lldb::eLanguageTypeJava)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeC99", lldb::eLanguageTypeC99)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeAda95", lldb::eLanguageTypeAda95)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeFortran95", lldb::eLanguageTypeFortran95)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypePLI", lldb::eLanguageTypePLI)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeObjC", lldb::eLanguageTypeObjC)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeObjC_plus_plus", lldb::eLanguageTypeObjC_plus_plus)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeUPC", lldb::eLanguageTypeUPC)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeD", lldb::eLanguageTypeD)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypePython", lldb::eLanguageTypePython)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeOpenCL", lldb::eLanguageTypeOpenCL)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeGo", lldb::eLanguageTypeGo)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeModula3", lldb::eLanguageTypeModula3)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeHaskell", lldb::eLanguageTypeHaskell)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeC_plus_plus_03", lldb::eLanguageTypeC_plus_plus_03)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeC_plus_plus_11", lldb::eLanguageTypeC_plus_plus_11)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeOCaml", lldb::eLanguageTypeOCaml)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeRust", lldb::eLanguageTypeRust)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeC11", lldb::eLanguageTypeC11)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeSwift", lldb::eLanguageTypeSwift)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeJulia", lldb::eLanguageTypeJulia)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeDylan", lldb::eLanguageTypeDylan)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeC_plus_plus_14", lldb::eLanguageTypeC_plus_plus_14)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeFortran03", lldb::eLanguageTypeFortran03)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeFortran08", lldb::eLanguageTypeFortran08)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeMipsAssembler", lldb::eLanguageTypeMipsAssembler)},
{SWIG_LUA_CONSTTAB_INT("eLanguageTypeExtRenderScript", lldb::eLanguageTypeExtRenderScript)},
{SWIG_LUA_CONSTTAB_INT("eNumLanguageTypes", lldb::eNumLanguageTypes)},
{SWIG_LUA_CONSTTAB_INT("eInstrumentationRuntimeTypeAddressSanitizer", lldb::eInstrumentationRuntimeTypeAddressSanitizer)},
{SWIG_LUA_CONSTTAB_INT("eInstrumentationRuntimeTypeThreadSanitizer", lldb::eInstrumentationRuntimeTypeThreadSanitizer)},
{SWIG_LUA_CONSTTAB_INT("eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer", lldb::eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer)},
{SWIG_LUA_CONSTTAB_INT("eInstrumentationRuntimeTypeMainThreadChecker", lldb::eInstrumentationRuntimeTypeMainThreadChecker)},
{SWIG_LUA_CONSTTAB_INT("eInstrumentationRuntimeTypeSwiftRuntimeReporting", lldb::eInstrumentationRuntimeTypeSwiftRuntimeReporting)},
{SWIG_LUA_CONSTTAB_INT("eNumInstrumentationRuntimeTypes", lldb::eNumInstrumentationRuntimeTypes)},
{SWIG_LUA_CONSTTAB_INT("eNoDynamicValues", lldb::eNoDynamicValues)},
{SWIG_LUA_CONSTTAB_INT("eDynamicCanRunTarget", lldb::eDynamicCanRunTarget)},
{SWIG_LUA_CONSTTAB_INT("eDynamicDontRunTarget", lldb::eDynamicDontRunTarget)},
{SWIG_LUA_CONSTTAB_INT("eStopShowColumnAnsiOrCaret", lldb::eStopShowColumnAnsiOrCaret)},
{SWIG_LUA_CONSTTAB_INT("eStopShowColumnAnsi", lldb::eStopShowColumnAnsi)},
{SWIG_LUA_CONSTTAB_INT("eStopShowColumnCaret", lldb::eStopShowColumnCaret)},
{SWIG_LUA_CONSTTAB_INT("eStopShowColumnNone", lldb::eStopShowColumnNone)},
{SWIG_LUA_CONSTTAB_INT("eAccessNone", lldb::eAccessNone)},
{SWIG_LUA_CONSTTAB_INT("eAccessPublic", lldb::eAccessPublic)},
{SWIG_LUA_CONSTTAB_INT("eAccessPrivate", lldb::eAccessPrivate)},
{SWIG_LUA_CONSTTAB_INT("eAccessProtected", lldb::eAccessProtected)},
{SWIG_LUA_CONSTTAB_INT("eAccessPackage", lldb::eAccessPackage)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeAddress", lldb::eArgTypeAddress)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeAddressOrExpression", lldb::eArgTypeAddressOrExpression)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeAliasName", lldb::eArgTypeAliasName)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeAliasOptions", lldb::eArgTypeAliasOptions)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeArchitecture", lldb::eArgTypeArchitecture)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeBoolean", lldb::eArgTypeBoolean)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeBreakpointID", lldb::eArgTypeBreakpointID)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeBreakpointIDRange", lldb::eArgTypeBreakpointIDRange)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeBreakpointName", lldb::eArgTypeBreakpointName)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeByteSize", lldb::eArgTypeByteSize)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeClassName", lldb::eArgTypeClassName)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeCommandName", lldb::eArgTypeCommandName)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeCount", lldb::eArgTypeCount)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeDescriptionVerbosity", lldb::eArgTypeDescriptionVerbosity)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeDirectoryName", lldb::eArgTypeDirectoryName)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeDisassemblyFlavor", lldb::eArgTypeDisassemblyFlavor)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeEndAddress", lldb::eArgTypeEndAddress)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeExpression", lldb::eArgTypeExpression)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeExpressionPath", lldb::eArgTypeExpressionPath)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeExprFormat", lldb::eArgTypeExprFormat)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeFileLineColumn", lldb::eArgTypeFileLineColumn)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeFilename", lldb::eArgTypeFilename)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeFormat", lldb::eArgTypeFormat)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeFrameIndex", lldb::eArgTypeFrameIndex)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeFullName", lldb::eArgTypeFullName)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeFunctionName", lldb::eArgTypeFunctionName)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeFunctionOrSymbol", lldb::eArgTypeFunctionOrSymbol)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeGDBFormat", lldb::eArgTypeGDBFormat)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeHelpText", lldb::eArgTypeHelpText)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeIndex", lldb::eArgTypeIndex)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeLanguage", lldb::eArgTypeLanguage)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeLineNum", lldb::eArgTypeLineNum)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeLogCategory", lldb::eArgTypeLogCategory)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeLogChannel", lldb::eArgTypeLogChannel)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeMethod", lldb::eArgTypeMethod)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeName", lldb::eArgTypeName)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeNewPathPrefix", lldb::eArgTypeNewPathPrefix)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeNumLines", lldb::eArgTypeNumLines)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeNumberPerLine", lldb::eArgTypeNumberPerLine)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeOffset", lldb::eArgTypeOffset)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeOldPathPrefix", lldb::eArgTypeOldPathPrefix)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeOneLiner", lldb::eArgTypeOneLiner)},
{SWIG_LUA_CONSTTAB_INT("eArgTypePath", lldb::eArgTypePath)},
{SWIG_LUA_CONSTTAB_INT("eArgTypePermissionsNumber", lldb::eArgTypePermissionsNumber)},
{SWIG_LUA_CONSTTAB_INT("eArgTypePermissionsString", lldb::eArgTypePermissionsString)},
{SWIG_LUA_CONSTTAB_INT("eArgTypePid", lldb::eArgTypePid)},
{SWIG_LUA_CONSTTAB_INT("eArgTypePlugin", lldb::eArgTypePlugin)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeProcessName", lldb::eArgTypeProcessName)},
{SWIG_LUA_CONSTTAB_INT("eArgTypePythonClass", lldb::eArgTypePythonClass)},
{SWIG_LUA_CONSTTAB_INT("eArgTypePythonFunction", lldb::eArgTypePythonFunction)},
{SWIG_LUA_CONSTTAB_INT("eArgTypePythonScript", lldb::eArgTypePythonScript)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeQueueName", lldb::eArgTypeQueueName)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeRegisterName", lldb::eArgTypeRegisterName)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeRegularExpression", lldb::eArgTypeRegularExpression)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeRunArgs", lldb::eArgTypeRunArgs)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeRunMode", lldb::eArgTypeRunMode)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeScriptedCommandSynchronicity", lldb::eArgTypeScriptedCommandSynchronicity)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeScriptLang", lldb::eArgTypeScriptLang)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeSearchWord", lldb::eArgTypeSearchWord)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeSelector", lldb::eArgTypeSelector)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeSettingIndex", lldb::eArgTypeSettingIndex)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeSettingKey", lldb::eArgTypeSettingKey)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeSettingPrefix", lldb::eArgTypeSettingPrefix)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeSettingVariableName", lldb::eArgTypeSettingVariableName)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeShlibName", lldb::eArgTypeShlibName)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeSourceFile", lldb::eArgTypeSourceFile)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeSortOrder", lldb::eArgTypeSortOrder)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeStartAddress", lldb::eArgTypeStartAddress)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeSummaryString", lldb::eArgTypeSummaryString)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeSymbol", lldb::eArgTypeSymbol)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeThreadID", lldb::eArgTypeThreadID)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeThreadIndex", lldb::eArgTypeThreadIndex)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeThreadName", lldb::eArgTypeThreadName)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeTypeName", lldb::eArgTypeTypeName)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeUnsignedInteger", lldb::eArgTypeUnsignedInteger)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeUnixSignal", lldb::eArgTypeUnixSignal)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeVarName", lldb::eArgTypeVarName)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeValue", lldb::eArgTypeValue)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeWidth", lldb::eArgTypeWidth)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeNone", lldb::eArgTypeNone)},
{SWIG_LUA_CONSTTAB_INT("eArgTypePlatform", lldb::eArgTypePlatform)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeWatchpointID", lldb::eArgTypeWatchpointID)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeWatchpointIDRange", lldb::eArgTypeWatchpointIDRange)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeWatchType", lldb::eArgTypeWatchType)},
{SWIG_LUA_CONSTTAB_INT("eArgRawInput", lldb::eArgRawInput)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeCommand", lldb::eArgTypeCommand)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeColumnNum", lldb::eArgTypeColumnNum)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeModuleUUID", lldb::eArgTypeModuleUUID)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeSaveCoreStyle", lldb::eArgTypeSaveCoreStyle)},
{SWIG_LUA_CONSTTAB_INT("eArgTypeLastArg", lldb::eArgTypeLastArg)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeAny", lldb::eSymbolTypeAny)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeInvalid", lldb::eSymbolTypeInvalid)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeAbsolute", lldb::eSymbolTypeAbsolute)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeCode", lldb::eSymbolTypeCode)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeResolver", lldb::eSymbolTypeResolver)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeData", lldb::eSymbolTypeData)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeTrampoline", lldb::eSymbolTypeTrampoline)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeRuntime", lldb::eSymbolTypeRuntime)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeException", lldb::eSymbolTypeException)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeSourceFile", lldb::eSymbolTypeSourceFile)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeHeaderFile", lldb::eSymbolTypeHeaderFile)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeObjectFile", lldb::eSymbolTypeObjectFile)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeCommonBlock", lldb::eSymbolTypeCommonBlock)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeBlock", lldb::eSymbolTypeBlock)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeLocal", lldb::eSymbolTypeLocal)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeParam", lldb::eSymbolTypeParam)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeVariable", lldb::eSymbolTypeVariable)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeVariableType", lldb::eSymbolTypeVariableType)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeLineEntry", lldb::eSymbolTypeLineEntry)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeLineHeader", lldb::eSymbolTypeLineHeader)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeScopeBegin", lldb::eSymbolTypeScopeBegin)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeScopeEnd", lldb::eSymbolTypeScopeEnd)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeAdditional", lldb::eSymbolTypeAdditional)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeCompiler", lldb::eSymbolTypeCompiler)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeInstrumentation", lldb::eSymbolTypeInstrumentation)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeUndefined", lldb::eSymbolTypeUndefined)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeObjCClass", lldb::eSymbolTypeObjCClass)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeObjCMetaClass", lldb::eSymbolTypeObjCMetaClass)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeObjCIVar", lldb::eSymbolTypeObjCIVar)},
{SWIG_LUA_CONSTTAB_INT("eSymbolTypeReExported", lldb::eSymbolTypeReExported)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeInvalid", lldb::eSectionTypeInvalid)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeCode", lldb::eSectionTypeCode)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeContainer", lldb::eSectionTypeContainer)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeData", lldb::eSectionTypeData)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDataCString", lldb::eSectionTypeDataCString)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDataCStringPointers", lldb::eSectionTypeDataCStringPointers)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDataSymbolAddress", lldb::eSectionTypeDataSymbolAddress)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeData4", lldb::eSectionTypeData4)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeData8", lldb::eSectionTypeData8)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeData16", lldb::eSectionTypeData16)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDataPointers", lldb::eSectionTypeDataPointers)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDebug", lldb::eSectionTypeDebug)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeZeroFill", lldb::eSectionTypeZeroFill)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDataObjCMessageRefs", lldb::eSectionTypeDataObjCMessageRefs)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDataObjCCFStrings", lldb::eSectionTypeDataObjCCFStrings)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugAbbrev", lldb::eSectionTypeDWARFDebugAbbrev)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugAddr", lldb::eSectionTypeDWARFDebugAddr)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugAranges", lldb::eSectionTypeDWARFDebugAranges)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugCuIndex", lldb::eSectionTypeDWARFDebugCuIndex)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugFrame", lldb::eSectionTypeDWARFDebugFrame)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugInfo", lldb::eSectionTypeDWARFDebugInfo)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugLine", lldb::eSectionTypeDWARFDebugLine)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugLoc", lldb::eSectionTypeDWARFDebugLoc)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugMacInfo", lldb::eSectionTypeDWARFDebugMacInfo)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugMacro", lldb::eSectionTypeDWARFDebugMacro)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugPubNames", lldb::eSectionTypeDWARFDebugPubNames)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugPubTypes", lldb::eSectionTypeDWARFDebugPubTypes)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugRanges", lldb::eSectionTypeDWARFDebugRanges)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugStr", lldb::eSectionTypeDWARFDebugStr)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugStrOffsets", lldb::eSectionTypeDWARFDebugStrOffsets)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFAppleNames", lldb::eSectionTypeDWARFAppleNames)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFAppleTypes", lldb::eSectionTypeDWARFAppleTypes)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFAppleNamespaces", lldb::eSectionTypeDWARFAppleNamespaces)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFAppleObjC", lldb::eSectionTypeDWARFAppleObjC)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeELFSymbolTable", lldb::eSectionTypeELFSymbolTable)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeELFDynamicSymbols", lldb::eSectionTypeELFDynamicSymbols)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeELFRelocationEntries", lldb::eSectionTypeELFRelocationEntries)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeELFDynamicLinkInfo", lldb::eSectionTypeELFDynamicLinkInfo)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeEHFrame", lldb::eSectionTypeEHFrame)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeARMexidx", lldb::eSectionTypeARMexidx)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeARMextab", lldb::eSectionTypeARMextab)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeCompactUnwind", lldb::eSectionTypeCompactUnwind)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeGoSymtab", lldb::eSectionTypeGoSymtab)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeAbsoluteAddress", lldb::eSectionTypeAbsoluteAddress)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFGNUDebugAltLink", lldb::eSectionTypeDWARFGNUDebugAltLink)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugTypes", lldb::eSectionTypeDWARFDebugTypes)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugNames", lldb::eSectionTypeDWARFDebugNames)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeOther", lldb::eSectionTypeOther)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugLineStr", lldb::eSectionTypeDWARFDebugLineStr)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugRngLists", lldb::eSectionTypeDWARFDebugRngLists)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugLocLists", lldb::eSectionTypeDWARFDebugLocLists)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugAbbrevDwo", lldb::eSectionTypeDWARFDebugAbbrevDwo)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugInfoDwo", lldb::eSectionTypeDWARFDebugInfoDwo)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugStrDwo", lldb::eSectionTypeDWARFDebugStrDwo)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugStrOffsetsDwo", lldb::eSectionTypeDWARFDebugStrOffsetsDwo)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugTypesDwo", lldb::eSectionTypeDWARFDebugTypesDwo)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugRngListsDwo", lldb::eSectionTypeDWARFDebugRngListsDwo)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugLocDwo", lldb::eSectionTypeDWARFDebugLocDwo)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugLocListsDwo", lldb::eSectionTypeDWARFDebugLocListsDwo)},
{SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugTuIndex", lldb::eSectionTypeDWARFDebugTuIndex)},
{SWIG_LUA_CONSTTAB_INT("eEmulateInstructionOptionNone", lldb::eEmulateInstructionOptionNone)},
{SWIG_LUA_CONSTTAB_INT("eEmulateInstructionOptionAutoAdvancePC", lldb::eEmulateInstructionOptionAutoAdvancePC)},
{SWIG_LUA_CONSTTAB_INT("eEmulateInstructionOptionIgnoreConditions", lldb::eEmulateInstructionOptionIgnoreConditions)},
{SWIG_LUA_CONSTTAB_INT("eFunctionNameTypeNone", lldb::eFunctionNameTypeNone)},
{SWIG_LUA_CONSTTAB_INT("eFunctionNameTypeAuto", lldb::eFunctionNameTypeAuto)},
{SWIG_LUA_CONSTTAB_INT("eFunctionNameTypeFull", lldb::eFunctionNameTypeFull)},
{SWIG_LUA_CONSTTAB_INT("eFunctionNameTypeBase", lldb::eFunctionNameTypeBase)},
{SWIG_LUA_CONSTTAB_INT("eFunctionNameTypeMethod", lldb::eFunctionNameTypeMethod)},
{SWIG_LUA_CONSTTAB_INT("eFunctionNameTypeSelector", lldb::eFunctionNameTypeSelector)},
{SWIG_LUA_CONSTTAB_INT("eFunctionNameTypeAny", lldb::eFunctionNameTypeAny)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeInvalid", lldb::eBasicTypeInvalid)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeVoid", lldb::eBasicTypeVoid)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeChar", lldb::eBasicTypeChar)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeSignedChar", lldb::eBasicTypeSignedChar)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeUnsignedChar", lldb::eBasicTypeUnsignedChar)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeWChar", lldb::eBasicTypeWChar)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeSignedWChar", lldb::eBasicTypeSignedWChar)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeUnsignedWChar", lldb::eBasicTypeUnsignedWChar)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeChar16", lldb::eBasicTypeChar16)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeChar32", lldb::eBasicTypeChar32)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeShort", lldb::eBasicTypeShort)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeUnsignedShort", lldb::eBasicTypeUnsignedShort)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeInt", lldb::eBasicTypeInt)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeUnsignedInt", lldb::eBasicTypeUnsignedInt)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeLong", lldb::eBasicTypeLong)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeUnsignedLong", lldb::eBasicTypeUnsignedLong)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeLongLong", lldb::eBasicTypeLongLong)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeUnsignedLongLong", lldb::eBasicTypeUnsignedLongLong)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeInt128", lldb::eBasicTypeInt128)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeUnsignedInt128", lldb::eBasicTypeUnsignedInt128)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeBool", lldb::eBasicTypeBool)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeHalf", lldb::eBasicTypeHalf)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeFloat", lldb::eBasicTypeFloat)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeDouble", lldb::eBasicTypeDouble)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeLongDouble", lldb::eBasicTypeLongDouble)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeFloatComplex", lldb::eBasicTypeFloatComplex)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeDoubleComplex", lldb::eBasicTypeDoubleComplex)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeLongDoubleComplex", lldb::eBasicTypeLongDoubleComplex)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeObjCID", lldb::eBasicTypeObjCID)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeObjCClass", lldb::eBasicTypeObjCClass)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeObjCSel", lldb::eBasicTypeObjCSel)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeNullPtr", lldb::eBasicTypeNullPtr)},
{SWIG_LUA_CONSTTAB_INT("eBasicTypeOther", lldb::eBasicTypeOther)},
{SWIG_LUA_CONSTTAB_INT("eTraceTypeNone", lldb::eTraceTypeNone)},
{SWIG_LUA_CONSTTAB_INT("eTraceTypeProcessorTrace", lldb::eTraceTypeProcessorTrace)},
{SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeInvalid", lldb::eStructuredDataTypeInvalid)},
{SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeNull", lldb::eStructuredDataTypeNull)},
{SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeGeneric", lldb::eStructuredDataTypeGeneric)},
{SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeArray", lldb::eStructuredDataTypeArray)},
{SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeInteger", lldb::eStructuredDataTypeInteger)},
{SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeFloat", lldb::eStructuredDataTypeFloat)},
{SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeBoolean", lldb::eStructuredDataTypeBoolean)},
{SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeString", lldb::eStructuredDataTypeString)},
{SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeDictionary", lldb::eStructuredDataTypeDictionary)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassInvalid", lldb::eTypeClassInvalid)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassArray", lldb::eTypeClassArray)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassBlockPointer", lldb::eTypeClassBlockPointer)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassBuiltin", lldb::eTypeClassBuiltin)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassClass", lldb::eTypeClassClass)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassComplexFloat", lldb::eTypeClassComplexFloat)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassComplexInteger", lldb::eTypeClassComplexInteger)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassEnumeration", lldb::eTypeClassEnumeration)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassFunction", lldb::eTypeClassFunction)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassMemberPointer", lldb::eTypeClassMemberPointer)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassObjCObject", lldb::eTypeClassObjCObject)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassObjCInterface", lldb::eTypeClassObjCInterface)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassObjCObjectPointer", lldb::eTypeClassObjCObjectPointer)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassPointer", lldb::eTypeClassPointer)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassReference", lldb::eTypeClassReference)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassStruct", lldb::eTypeClassStruct)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassTypedef", lldb::eTypeClassTypedef)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassUnion", lldb::eTypeClassUnion)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassVector", lldb::eTypeClassVector)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassOther", lldb::eTypeClassOther)},
{SWIG_LUA_CONSTTAB_INT("eTypeClassAny", lldb::eTypeClassAny)},
{SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindNull", lldb::eTemplateArgumentKindNull)},
{SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindType", lldb::eTemplateArgumentKindType)},
{SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindDeclaration", lldb::eTemplateArgumentKindDeclaration)},
{SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindIntegral", lldb::eTemplateArgumentKindIntegral)},
{SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindTemplate", lldb::eTemplateArgumentKindTemplate)},
{SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindTemplateExpansion", lldb::eTemplateArgumentKindTemplateExpansion)},
{SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindExpression", lldb::eTemplateArgumentKindExpression)},
{SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindPack", lldb::eTemplateArgumentKindPack)},
{SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindNullPtr", lldb::eTemplateArgumentKindNullPtr)},
{SWIG_LUA_CONSTTAB_INT("eTypeOptionNone", lldb::eTypeOptionNone)},
{SWIG_LUA_CONSTTAB_INT("eTypeOptionCascade", lldb::eTypeOptionCascade)},
{SWIG_LUA_CONSTTAB_INT("eTypeOptionSkipPointers", lldb::eTypeOptionSkipPointers)},
{SWIG_LUA_CONSTTAB_INT("eTypeOptionSkipReferences", lldb::eTypeOptionSkipReferences)},
{SWIG_LUA_CONSTTAB_INT("eTypeOptionHideChildren", lldb::eTypeOptionHideChildren)},
{SWIG_LUA_CONSTTAB_INT("eTypeOptionHideValue", lldb::eTypeOptionHideValue)},
{SWIG_LUA_CONSTTAB_INT("eTypeOptionShowOneLiner", lldb::eTypeOptionShowOneLiner)},
{SWIG_LUA_CONSTTAB_INT("eTypeOptionHideNames", lldb::eTypeOptionHideNames)},
{SWIG_LUA_CONSTTAB_INT("eTypeOptionNonCacheable", lldb::eTypeOptionNonCacheable)},
{SWIG_LUA_CONSTTAB_INT("eTypeOptionHideEmptyAggregates", lldb::eTypeOptionHideEmptyAggregates)},
{SWIG_LUA_CONSTTAB_INT("eTypeOptionFrontEndWantsDereference", lldb::eTypeOptionFrontEndWantsDereference)},
{SWIG_LUA_CONSTTAB_INT("eFrameCompareInvalid", lldb::eFrameCompareInvalid)},
{SWIG_LUA_CONSTTAB_INT("eFrameCompareUnknown", lldb::eFrameCompareUnknown)},
{SWIG_LUA_CONSTTAB_INT("eFrameCompareEqual", lldb::eFrameCompareEqual)},
{SWIG_LUA_CONSTTAB_INT("eFrameCompareSameParent", lldb::eFrameCompareSameParent)},
{SWIG_LUA_CONSTTAB_INT("eFrameCompareYounger", lldb::eFrameCompareYounger)},
{SWIG_LUA_CONSTTAB_INT("eFrameCompareOlder", lldb::eFrameCompareOlder)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsUserRead", lldb::eFilePermissionsUserRead)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsUserWrite", lldb::eFilePermissionsUserWrite)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsUserExecute", lldb::eFilePermissionsUserExecute)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsGroupRead", lldb::eFilePermissionsGroupRead)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsGroupWrite", lldb::eFilePermissionsGroupWrite)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsGroupExecute", lldb::eFilePermissionsGroupExecute)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsWorldRead", lldb::eFilePermissionsWorldRead)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsWorldWrite", lldb::eFilePermissionsWorldWrite)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsWorldExecute", lldb::eFilePermissionsWorldExecute)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsUserRW", lldb::eFilePermissionsUserRW)},
{SWIG_LUA_CONSTTAB_INT("eFileFilePermissionsUserRX", lldb::eFileFilePermissionsUserRX)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsUserRWX", lldb::eFilePermissionsUserRWX)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsGroupRW", lldb::eFilePermissionsGroupRW)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsGroupRX", lldb::eFilePermissionsGroupRX)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsGroupRWX", lldb::eFilePermissionsGroupRWX)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsWorldRW", lldb::eFilePermissionsWorldRW)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsWorldRX", lldb::eFilePermissionsWorldRX)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsWorldRWX", lldb::eFilePermissionsWorldRWX)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsEveryoneR", lldb::eFilePermissionsEveryoneR)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsEveryoneW", lldb::eFilePermissionsEveryoneW)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsEveryoneX", lldb::eFilePermissionsEveryoneX)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsEveryoneRW", lldb::eFilePermissionsEveryoneRW)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsEveryoneRX", lldb::eFilePermissionsEveryoneRX)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsEveryoneRWX", lldb::eFilePermissionsEveryoneRWX)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsFileDefault", lldb::eFilePermissionsFileDefault)},
{SWIG_LUA_CONSTTAB_INT("eFilePermissionsDirectoryDefault", lldb::eFilePermissionsDirectoryDefault)},
{SWIG_LUA_CONSTTAB_INT("eQueueItemKindUnknown", lldb::eQueueItemKindUnknown)},
{SWIG_LUA_CONSTTAB_INT("eQueueItemKindFunction", lldb::eQueueItemKindFunction)},
{SWIG_LUA_CONSTTAB_INT("eQueueItemKindBlock", lldb::eQueueItemKindBlock)},
{SWIG_LUA_CONSTTAB_INT("eQueueKindUnknown", lldb::eQueueKindUnknown)},
{SWIG_LUA_CONSTTAB_INT("eQueueKindSerial", lldb::eQueueKindSerial)},
{SWIG_LUA_CONSTTAB_INT("eQueueKindConcurrent", lldb::eQueueKindConcurrent)},
{SWIG_LUA_CONSTTAB_INT("eExpressionEvaluationParse", lldb::eExpressionEvaluationParse)},
{SWIG_LUA_CONSTTAB_INT("eExpressionEvaluationIRGen", lldb::eExpressionEvaluationIRGen)},
{SWIG_LUA_CONSTTAB_INT("eExpressionEvaluationExecution", lldb::eExpressionEvaluationExecution)},
{SWIG_LUA_CONSTTAB_INT("eExpressionEvaluationComplete", lldb::eExpressionEvaluationComplete)},
{SWIG_LUA_CONSTTAB_INT("eTraceInstructionControlFlowTypeInstruction", lldb::eTraceInstructionControlFlowTypeInstruction)},
{SWIG_LUA_CONSTTAB_INT("eTraceInstructionControlFlowTypeBranch", lldb::eTraceInstructionControlFlowTypeBranch)},
{SWIG_LUA_CONSTTAB_INT("eTraceInstructionControlFlowTypeTakenBranch", lldb::eTraceInstructionControlFlowTypeTakenBranch)},
{SWIG_LUA_CONSTTAB_INT("eTraceInstructionControlFlowTypeCall", lldb::eTraceInstructionControlFlowTypeCall)},
{SWIG_LUA_CONSTTAB_INT("eTraceInstructionControlFlowTypeReturn", lldb::eTraceInstructionControlFlowTypeReturn)},
{SWIG_LUA_CONSTTAB_INT("eWatchpointKindWrite", lldb::eWatchpointKindWrite)},
{SWIG_LUA_CONSTTAB_INT("eWatchpointKindRead", lldb::eWatchpointKindRead)},
{SWIG_LUA_CONSTTAB_INT("eGdbSignalBadAccess", lldb::eGdbSignalBadAccess)},
{SWIG_LUA_CONSTTAB_INT("eGdbSignalBadInstruction", lldb::eGdbSignalBadInstruction)},
{SWIG_LUA_CONSTTAB_INT("eGdbSignalArithmetic", lldb::eGdbSignalArithmetic)},
{SWIG_LUA_CONSTTAB_INT("eGdbSignalEmulation", lldb::eGdbSignalEmulation)},
{SWIG_LUA_CONSTTAB_INT("eGdbSignalSoftware", lldb::eGdbSignalSoftware)},
{SWIG_LUA_CONSTTAB_INT("eGdbSignalBreakpoint", lldb::eGdbSignalBreakpoint)},
{SWIG_LUA_CONSTTAB_INT("ePathTypeLLDBShlibDir", lldb::ePathTypeLLDBShlibDir)},
{SWIG_LUA_CONSTTAB_INT("ePathTypeSupportExecutableDir", lldb::ePathTypeSupportExecutableDir)},
{SWIG_LUA_CONSTTAB_INT("ePathTypeHeaderDir", lldb::ePathTypeHeaderDir)},
{SWIG_LUA_CONSTTAB_INT("ePathTypePythonDir", lldb::ePathTypePythonDir)},
{SWIG_LUA_CONSTTAB_INT("ePathTypeLLDBSystemPlugins", lldb::ePathTypeLLDBSystemPlugins)},
{SWIG_LUA_CONSTTAB_INT("ePathTypeLLDBUserPlugins", lldb::ePathTypeLLDBUserPlugins)},
{SWIG_LUA_CONSTTAB_INT("ePathTypeLLDBTempSystemDir", lldb::ePathTypeLLDBTempSystemDir)},
{SWIG_LUA_CONSTTAB_INT("ePathTypeGlobalLLDBTempSystemDir", lldb::ePathTypeGlobalLLDBTempSystemDir)},
{SWIG_LUA_CONSTTAB_INT("ePathTypeClangDir", lldb::ePathTypeClangDir)},
{SWIG_LUA_CONSTTAB_INT("eMemberFunctionKindUnknown", lldb::eMemberFunctionKindUnknown)},
{SWIG_LUA_CONSTTAB_INT("eMemberFunctionKindConstructor", lldb::eMemberFunctionKindConstructor)},
{SWIG_LUA_CONSTTAB_INT("eMemberFunctionKindDestructor", lldb::eMemberFunctionKindDestructor)},
{SWIG_LUA_CONSTTAB_INT("eMemberFunctionKindInstanceMethod", lldb::eMemberFunctionKindInstanceMethod)},
{SWIG_LUA_CONSTTAB_INT("eMemberFunctionKindStaticMethod", lldb::eMemberFunctionKindStaticMethod)},
{SWIG_LUA_CONSTTAB_INT("eMatchTypeNormal", lldb::eMatchTypeNormal)},
{SWIG_LUA_CONSTTAB_INT("eMatchTypeRegex", lldb::eMatchTypeRegex)},
{SWIG_LUA_CONSTTAB_INT("eMatchTypeStartsWith", lldb::eMatchTypeStartsWith)},
{SWIG_LUA_CONSTTAB_INT("eTypeHasChildren", lldb::eTypeHasChildren)},
{SWIG_LUA_CONSTTAB_INT("eTypeHasValue", lldb::eTypeHasValue)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsArray", lldb::eTypeIsArray)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsBlock", lldb::eTypeIsBlock)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsBuiltIn", lldb::eTypeIsBuiltIn)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsClass", lldb::eTypeIsClass)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsCPlusPlus", lldb::eTypeIsCPlusPlus)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsEnumeration", lldb::eTypeIsEnumeration)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsFuncPrototype", lldb::eTypeIsFuncPrototype)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsMember", lldb::eTypeIsMember)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsObjC", lldb::eTypeIsObjC)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsPointer", lldb::eTypeIsPointer)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsReference", lldb::eTypeIsReference)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsStructUnion", lldb::eTypeIsStructUnion)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsTemplate", lldb::eTypeIsTemplate)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsTypedef", lldb::eTypeIsTypedef)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsVector", lldb::eTypeIsVector)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsScalar", lldb::eTypeIsScalar)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsInteger", lldb::eTypeIsInteger)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsFloat", lldb::eTypeIsFloat)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsComplex", lldb::eTypeIsComplex)},
{SWIG_LUA_CONSTTAB_INT("eTypeIsSigned", lldb::eTypeIsSigned)},
{SWIG_LUA_CONSTTAB_INT("eTypeInstanceIsPointer", lldb::eTypeInstanceIsPointer)},
{SWIG_LUA_CONSTTAB_INT("eCommandRequiresTarget", lldb::eCommandRequiresTarget)},
{SWIG_LUA_CONSTTAB_INT("eCommandRequiresProcess", lldb::eCommandRequiresProcess)},
{SWIG_LUA_CONSTTAB_INT("eCommandRequiresThread", lldb::eCommandRequiresThread)},
{SWIG_LUA_CONSTTAB_INT("eCommandRequiresFrame", lldb::eCommandRequiresFrame)},
{SWIG_LUA_CONSTTAB_INT("eCommandRequiresRegContext", lldb::eCommandRequiresRegContext)},
{SWIG_LUA_CONSTTAB_INT("eCommandTryTargetAPILock", lldb::eCommandTryTargetAPILock)},
{SWIG_LUA_CONSTTAB_INT("eCommandProcessMustBeLaunched", lldb::eCommandProcessMustBeLaunched)},
{SWIG_LUA_CONSTTAB_INT("eCommandProcessMustBePaused", lldb::eCommandProcessMustBePaused)},
{SWIG_LUA_CONSTTAB_INT("eCommandProcessMustBeTraced", lldb::eCommandProcessMustBeTraced)},
{SWIG_LUA_CONSTTAB_INT("eTypeSummaryCapped", lldb::eTypeSummaryCapped)},
{SWIG_LUA_CONSTTAB_INT("eTypeSummaryUncapped", lldb::eTypeSummaryUncapped)},
{SWIG_LUA_CONSTTAB_INT("eCommandInterpreterResultSuccess", lldb::eCommandInterpreterResultSuccess)},
{SWIG_LUA_CONSTTAB_INT("eCommandInterpreterResultInferiorCrash", lldb::eCommandInterpreterResultInferiorCrash)},
{SWIG_LUA_CONSTTAB_INT("eCommandInterpreterResultCommandError", lldb::eCommandInterpreterResultCommandError)},
{SWIG_LUA_CONSTTAB_INT("eCommandInterpreterResultQuitRequested", lldb::eCommandInterpreterResultQuitRequested)},
{SWIG_LUA_CONSTTAB_INT("eSaveCoreUnspecified", lldb::eSaveCoreUnspecified)},
{SWIG_LUA_CONSTTAB_INT("eSaveCoreFull", lldb::eSaveCoreFull)},
{SWIG_LUA_CONSTTAB_INT("eSaveCoreDirtyOnly", lldb::eSaveCoreDirtyOnly)},
{SWIG_LUA_CONSTTAB_INT("eSaveCoreStackOnly", lldb::eSaveCoreStackOnly)},
{SWIG_LUA_CONSTTAB_INT("SBCommandInterpreter_eBroadcastBitThreadShouldExit", lldb::SBCommandInterpreter::eBroadcastBitThreadShouldExit)},
{SWIG_LUA_CONSTTAB_INT("SBCommandInterpreter_eBroadcastBitResetPrompt", lldb::SBCommandInterpreter::eBroadcastBitResetPrompt)},
{SWIG_LUA_CONSTTAB_INT("SBCommandInterpreter_eBroadcastBitQuitCommandReceived", lldb::SBCommandInterpreter::eBroadcastBitQuitCommandReceived)},
{SWIG_LUA_CONSTTAB_INT("SBCommandInterpreter_eBroadcastBitAsynchronousOutputData", lldb::SBCommandInterpreter::eBroadcastBitAsynchronousOutputData)},
{SWIG_LUA_CONSTTAB_INT("SBCommandInterpreter_eBroadcastBitAsynchronousErrorData", lldb::SBCommandInterpreter::eBroadcastBitAsynchronousErrorData)},
{SWIG_LUA_CONSTTAB_INT("SBCommunication_eBroadcastBitDisconnected", lldb::SBCommunication::eBroadcastBitDisconnected)},
{SWIG_LUA_CONSTTAB_INT("SBCommunication_eBroadcastBitReadThreadGotBytes", lldb::SBCommunication::eBroadcastBitReadThreadGotBytes)},
{SWIG_LUA_CONSTTAB_INT("SBCommunication_eBroadcastBitReadThreadDidExit", lldb::SBCommunication::eBroadcastBitReadThreadDidExit)},
{SWIG_LUA_CONSTTAB_INT("SBCommunication_eBroadcastBitReadThreadShouldExit", lldb::SBCommunication::eBroadcastBitReadThreadShouldExit)},
{SWIG_LUA_CONSTTAB_INT("SBCommunication_eBroadcastBitPacketAvailable", lldb::SBCommunication::eBroadcastBitPacketAvailable)},
{SWIG_LUA_CONSTTAB_INT("SBCommunication_eAllEventBits", lldb::SBCommunication::eAllEventBits)},
{SWIG_LUA_CONSTTAB_INT("SBProcess_eBroadcastBitStateChanged", lldb::SBProcess::eBroadcastBitStateChanged)},
{SWIG_LUA_CONSTTAB_INT("SBProcess_eBroadcastBitInterrupt", lldb::SBProcess::eBroadcastBitInterrupt)},
{SWIG_LUA_CONSTTAB_INT("SBProcess_eBroadcastBitSTDOUT", lldb::SBProcess::eBroadcastBitSTDOUT)},
{SWIG_LUA_CONSTTAB_INT("SBProcess_eBroadcastBitSTDERR", lldb::SBProcess::eBroadcastBitSTDERR)},
{SWIG_LUA_CONSTTAB_INT("SBProcess_eBroadcastBitProfileData", lldb::SBProcess::eBroadcastBitProfileData)},
{SWIG_LUA_CONSTTAB_INT("SBProcess_eBroadcastBitStructuredData", lldb::SBProcess::eBroadcastBitStructuredData)},
{SWIG_LUA_CONSTTAB_INT("SBTarget_eBroadcastBitBreakpointChanged", lldb::SBTarget::eBroadcastBitBreakpointChanged)},
{SWIG_LUA_CONSTTAB_INT("SBTarget_eBroadcastBitModulesLoaded", lldb::SBTarget::eBroadcastBitModulesLoaded)},
{SWIG_LUA_CONSTTAB_INT("SBTarget_eBroadcastBitModulesUnloaded", lldb::SBTarget::eBroadcastBitModulesUnloaded)},
{SWIG_LUA_CONSTTAB_INT("SBTarget_eBroadcastBitWatchpointChanged", lldb::SBTarget::eBroadcastBitWatchpointChanged)},
{SWIG_LUA_CONSTTAB_INT("SBTarget_eBroadcastBitSymbolsLoaded", lldb::SBTarget::eBroadcastBitSymbolsLoaded)},
{SWIG_LUA_CONSTTAB_INT("SBThread_eBroadcastBitStackChanged", lldb::SBThread::eBroadcastBitStackChanged)},
{SWIG_LUA_CONSTTAB_INT("SBThread_eBroadcastBitThreadSuspended", lldb::SBThread::eBroadcastBitThreadSuspended)},
{SWIG_LUA_CONSTTAB_INT("SBThread_eBroadcastBitThreadResumed", lldb::SBThread::eBroadcastBitThreadResumed)},
{SWIG_LUA_CONSTTAB_INT("SBThread_eBroadcastBitSelectedFrameChanged", lldb::SBThread::eBroadcastBitSelectedFrameChanged)},
{SWIG_LUA_CONSTTAB_INT("SBThread_eBroadcastBitThreadSelected", lldb::SBThread::eBroadcastBitThreadSelected)},
{0,0,0,0,0,0}
};
static swig_lua_method swig_SwigModule_methods[]= {
{ "SBBreakpoint_EventIsBreakpointEvent", _wrap_SBBreakpoint_EventIsBreakpointEvent},
{ "SBBreakpoint_GetBreakpointEventTypeFromEvent", _wrap_SBBreakpoint_GetBreakpointEventTypeFromEvent},
{ "SBBreakpoint_GetBreakpointFromEvent", _wrap_SBBreakpoint_GetBreakpointFromEvent},
{ "SBBreakpoint_GetBreakpointLocationAtIndexFromEvent", _wrap_SBBreakpoint_GetBreakpointLocationAtIndexFromEvent},
{ "SBBreakpoint_GetNumBreakpointLocationsFromEvent", _wrap_SBBreakpoint_GetNumBreakpointLocationsFromEvent},
{ "SBCommandInterpreter_GetArgumentTypeAsCString", _wrap_SBCommandInterpreter_GetArgumentTypeAsCString},
{ "SBCommandInterpreter_GetArgumentDescriptionAsCString", _wrap_SBCommandInterpreter_GetArgumentDescriptionAsCString},
{ "SBCommandInterpreter_EventIsCommandInterpreterEvent", _wrap_SBCommandInterpreter_EventIsCommandInterpreterEvent},
{ "SBCommandInterpreter_GetBroadcasterClass", _wrap_SBCommandInterpreter_GetBroadcasterClass},
{ "SBCommunication_GetBroadcasterClass", _wrap_SBCommunication_GetBroadcasterClass},
{ "SBData_CreateDataFromCString", _wrap_SBData_CreateDataFromCString},
{ "SBData_CreateDataFromUInt64Array", _wrap_SBData_CreateDataFromUInt64Array},
{ "SBData_CreateDataFromUInt32Array", _wrap_SBData_CreateDataFromUInt32Array},
{ "SBData_CreateDataFromSInt64Array", _wrap_SBData_CreateDataFromSInt64Array},
{ "SBData_CreateDataFromSInt32Array", _wrap_SBData_CreateDataFromSInt32Array},
{ "SBData_CreateDataFromDoubleArray", _wrap_SBData_CreateDataFromDoubleArray},
{ "SBDebugger_Initialize", _wrap_SBDebugger_Initialize},
{ "SBDebugger_InitializeWithErrorHandling", _wrap_SBDebugger_InitializeWithErrorHandling},
{ "SBDebugger_Terminate", _wrap_SBDebugger_Terminate},
{ "SBDebugger_Create", _wrap_SBDebugger_Create},
{ "SBDebugger_Destroy", _wrap_SBDebugger_Destroy},
{ "SBDebugger_MemoryPressureDetected", _wrap_SBDebugger_MemoryPressureDetected},
{ "SBDebugger_GetDefaultArchitecture", _wrap_SBDebugger_GetDefaultArchitecture},
{ "SBDebugger_SetDefaultArchitecture", _wrap_SBDebugger_SetDefaultArchitecture},
{ "SBDebugger_GetVersionString", _wrap_SBDebugger_GetVersionString},
{ "SBDebugger_StateAsCString", _wrap_SBDebugger_StateAsCString},
{ "SBDebugger_GetBuildConfiguration", _wrap_SBDebugger_GetBuildConfiguration},
{ "SBDebugger_StateIsRunningState", _wrap_SBDebugger_StateIsRunningState},
{ "SBDebugger_StateIsStoppedState", _wrap_SBDebugger_StateIsStoppedState},
{ "SBDebugger_FindDebuggerWithID", _wrap_SBDebugger_FindDebuggerWithID},
{ "SBDebugger_SetInternalVariable", _wrap_SBDebugger_SetInternalVariable},
{ "SBDebugger_GetInternalVariableValue", _wrap_SBDebugger_GetInternalVariableValue},
{ "SBEvent_GetCStringFromEvent", _wrap_SBEvent_GetCStringFromEvent},
{ "SBFile_MakeBorrowed", _wrap_SBFile_MakeBorrowed},
{ "SBFile_MakeForcingIOMethods", _wrap_SBFile_MakeForcingIOMethods},
{ "SBFile_MakeBorrowedForcingIOMethods", _wrap_SBFile_MakeBorrowedForcingIOMethods},
{ "SBFileSpec_ResolvePath", _wrap_SBFileSpec_ResolvePath},
{ "SBHostOS_GetProgramFileSpec", _wrap_SBHostOS_GetProgramFileSpec},
{ "SBHostOS_GetLLDBPythonPath", _wrap_SBHostOS_GetLLDBPythonPath},
{ "SBHostOS_GetLLDBPath", _wrap_SBHostOS_GetLLDBPath},
{ "SBHostOS_GetUserHomeDirectory", _wrap_SBHostOS_GetUserHomeDirectory},
{ "SBHostOS_ThreadCreated", _wrap_SBHostOS_ThreadCreated},
{ "SBHostOS_ThreadCreate", _wrap_SBHostOS_ThreadCreate},
{ "SBHostOS_ThreadCancel", _wrap_SBHostOS_ThreadCancel},
{ "SBHostOS_ThreadDetach", _wrap_SBHostOS_ThreadDetach},
{ "SBHostOS_ThreadJoin", _wrap_SBHostOS_ThreadJoin},
{ "SBLanguageRuntime_GetLanguageTypeFromString", _wrap_SBLanguageRuntime_GetLanguageTypeFromString},
{ "SBLanguageRuntime_GetNameForLanguageType", _wrap_SBLanguageRuntime_GetNameForLanguageType},
{ "SBModule_GetNumberAllocatedModules", _wrap_SBModule_GetNumberAllocatedModules},
{ "SBModule_GarbageCollectAllocatedModules", _wrap_SBModule_GarbageCollectAllocatedModules},
{ "SBModuleSpecList_GetModuleSpecifications", _wrap_SBModuleSpecList_GetModuleSpecifications},
{ "SBPlatform_GetHostPlatform", _wrap_SBPlatform_GetHostPlatform},
{ "SBProcess_GetBroadcasterClassName", _wrap_SBProcess_GetBroadcasterClassName},
{ "SBProcess_GetStateFromEvent", _wrap_SBProcess_GetStateFromEvent},
{ "SBProcess_GetRestartedFromEvent", _wrap_SBProcess_GetRestartedFromEvent},
{ "SBProcess_GetNumRestartedReasonsFromEvent", _wrap_SBProcess_GetNumRestartedReasonsFromEvent},
{ "SBProcess_GetRestartedReasonAtIndexFromEvent", _wrap_SBProcess_GetRestartedReasonAtIndexFromEvent},
{ "SBProcess_GetProcessFromEvent", _wrap_SBProcess_GetProcessFromEvent},
{ "SBProcess_GetInterruptedFromEvent", _wrap_SBProcess_GetInterruptedFromEvent},
{ "SBProcess_GetStructuredDataFromEvent", _wrap_SBProcess_GetStructuredDataFromEvent},
{ "SBProcess_EventIsProcessEvent", _wrap_SBProcess_EventIsProcessEvent},
{ "SBProcess_EventIsStructuredDataEvent", _wrap_SBProcess_EventIsStructuredDataEvent},
{ "SBReproducer_Capture", _wrap_SBReproducer_Capture},
{ "SBReproducer_PassiveReplay", _wrap_SBReproducer_PassiveReplay},
{ "SBReproducer_SetAutoGenerate", _wrap_SBReproducer_SetAutoGenerate},
{ "SBReproducer_SetWorkingDirectory", _wrap_SBReproducer_SetWorkingDirectory},
{ "SBTarget_GetBroadcasterClassName", _wrap_SBTarget_GetBroadcasterClassName},
{ "SBTarget_EventIsTargetEvent", _wrap_SBTarget_EventIsTargetEvent},
{ "SBTarget_GetTargetFromEvent", _wrap_SBTarget_GetTargetFromEvent},
{ "SBTarget_GetNumModulesFromEvent", _wrap_SBTarget_GetNumModulesFromEvent},
{ "SBTarget_GetModuleAtIndexFromEvent", _wrap_SBTarget_GetModuleAtIndexFromEvent},
{ "SBThread_GetBroadcasterClassName", _wrap_SBThread_GetBroadcasterClassName},
{ "SBThread_EventIsThreadEvent", _wrap_SBThread_EventIsThreadEvent},
{ "SBThread_GetStackFrameFromEvent", _wrap_SBThread_GetStackFrameFromEvent},
{ "SBThread_GetThreadFromEvent", _wrap_SBThread_GetThreadFromEvent},
{ "SBTypeSummary_CreateWithSummaryString", _wrap_SBTypeSummary_CreateWithSummaryString},
{ "SBTypeSummary_CreateWithFunctionName", _wrap_SBTypeSummary_CreateWithFunctionName},
{ "SBTypeSummary_CreateWithScriptCode", _wrap_SBTypeSummary_CreateWithScriptCode},
{ "SBTypeSynthetic_CreateWithClassName", _wrap_SBTypeSynthetic_CreateWithClassName},
{ "SBTypeSynthetic_CreateWithScriptCode", _wrap_SBTypeSynthetic_CreateWithScriptCode},
{ "SBWatchpoint_EventIsWatchpointEvent", _wrap_SBWatchpoint_EventIsWatchpointEvent},
{ "SBWatchpoint_GetWatchpointEventTypeFromEvent", _wrap_SBWatchpoint_GetWatchpointEventTypeFromEvent},
{ "SBWatchpoint_GetWatchpointFromEvent", _wrap_SBWatchpoint_GetWatchpointFromEvent},
{0,0}
};
static swig_lua_class* swig_SwigModule_classes[]= {
&_wrap_class_string,
&_wrap_class_SBAddress,
&_wrap_class_SBAttachInfo,
&_wrap_class_SBBlock,
&_wrap_class_SBBreakpoint,
&_wrap_class_SBBreakpointList,
&_wrap_class_SBBreakpointLocation,
&_wrap_class_SBBreakpointName,
&_wrap_class_SBBroadcaster,
&_wrap_class_SBCommandInterpreter,
&_wrap_class_SBCommandInterpreterRunOptions,
&_wrap_class_SBCommandReturnObject,
&_wrap_class_SBCommunication,
&_wrap_class_SBCompileUnit,
&_wrap_class_SBData,
&_wrap_class_SBDebugger,
&_wrap_class_SBDeclaration,
&_wrap_class_SBError,
&_wrap_class_SBEnvironment,
&_wrap_class_SBEvent,
&_wrap_class_SBExecutionContext,
&_wrap_class_SBExpressionOptions,
&_wrap_class_SBFile,
&_wrap_class_SBFileSpec,
&_wrap_class_SBFileSpecList,
&_wrap_class_SBFrame,
&_wrap_class_SBFunction,
&_wrap_class_SBHostOS,
&_wrap_class_SBInstruction,
&_wrap_class_SBInstructionList,
&_wrap_class_SBLanguageRuntime,
&_wrap_class_SBLaunchInfo,
&_wrap_class_SBLineEntry,
&_wrap_class_SBListener,
&_wrap_class_SBMemoryRegionInfo,
&_wrap_class_SBMemoryRegionInfoList,
&_wrap_class_SBModule,
&_wrap_class_SBModuleSpec,
&_wrap_class_SBModuleSpecList,
&_wrap_class_SBPlatformConnectOptions,
&_wrap_class_SBPlatformShellCommand,
&_wrap_class_SBPlatform,
&_wrap_class_SBProcess,
&_wrap_class_SBProcessInfo,
&_wrap_class_SBQueue,
&_wrap_class_SBQueueItem,
&_wrap_class_SBReproducer,
&_wrap_class_SBSection,
&_wrap_class_SBSourceManager,
&_wrap_class_SBStream,
&_wrap_class_SBStringList,
&_wrap_class_SBStructuredData,
&_wrap_class_SBSymbol,
&_wrap_class_SBSymbolContext,
&_wrap_class_SBSymbolContextList,
&_wrap_class_SBTarget,
&_wrap_class_SBThread,
&_wrap_class_SBThreadCollection,
&_wrap_class_SBThreadPlan,
&_wrap_class_SBTrace,
&_wrap_class_SBTypeMember,
&_wrap_class_SBTypeMemberFunction,
&_wrap_class_SBType,
&_wrap_class_SBTypeList,
&_wrap_class_SBTypeCategory,
&_wrap_class_SBTypeEnumMember,
&_wrap_class_SBTypeEnumMemberList,
&_wrap_class_SBTypeFilter,
&_wrap_class_SBTypeFormat,
&_wrap_class_SBTypeNameSpecifier,
&_wrap_class_SBTypeSummaryOptions,
&_wrap_class_SBTypeSummary,
&_wrap_class_SBTypeSynthetic,
&_wrap_class_SBUnixSignals,
&_wrap_class_SBValue,
&_wrap_class_SBValueList,
&_wrap_class_SBVariablesOptions,
&_wrap_class_SBWatchpoint,
0
};
static swig_lua_namespace* swig_SwigModule_namespaces[] = {
0
};
static swig_lua_namespace swig_SwigModule = {
"lldb",
swig_SwigModule_methods,
swig_SwigModule_attributes,
swig_SwigModule_constants,
swig_SwigModule_classes,
swig_SwigModule_namespaces
};
#ifdef __cplusplus
}
#endif
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_void__void = {"_p_f_p_q_const__char_p_void__void", "void (*)(char const *,void *)|lldb::LogOutputCallback", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void__p_void = {"_p_f_p_void__p_void", "lldb::thread_func_t|void *(*)(void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__void_size_t__void = {"_p_f_p_void_p_q_const__void_size_t__void", "void (*)(void *,void const *,size_t)|lldb::SBCommunication::ReadThreadBytesReceived", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "intptr_t *|int *|lldb::file_t *|int_least32_t *|int_fast32_t *|int32_t *|lldb::pipe_t *|lldb::watch_id_t *|lldb::socket_t *|lldb::break_id_t *|int_fast16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__ConnectionStatus = {"_p_lldb__ConnectionStatus", "enum lldb::ConnectionStatus *|lldb::ConnectionStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBAddress = {"_p_lldb__SBAddress", "lldb::SBAddress *", 0, 0, (void*)&_wrap_class_SBAddress, 0};
static swig_type_info _swigt__p_lldb__SBAttachInfo = {"_p_lldb__SBAttachInfo", "lldb::SBAttachInfo *", 0, 0, (void*)&_wrap_class_SBAttachInfo, 0};
static swig_type_info _swigt__p_lldb__SBBlock = {"_p_lldb__SBBlock", "lldb::SBBlock *", 0, 0, (void*)&_wrap_class_SBBlock, 0};
static swig_type_info _swigt__p_lldb__SBBreakpoint = {"_p_lldb__SBBreakpoint", "lldb::SBBreakpoint *", 0, 0, (void*)&_wrap_class_SBBreakpoint, 0};
static swig_type_info _swigt__p_lldb__SBBreakpointList = {"_p_lldb__SBBreakpointList", "lldb::SBBreakpointList *", 0, 0, (void*)&_wrap_class_SBBreakpointList, 0};
static swig_type_info _swigt__p_lldb__SBBreakpointLocation = {"_p_lldb__SBBreakpointLocation", "lldb::SBBreakpointLocation *", 0, 0, (void*)&_wrap_class_SBBreakpointLocation, 0};
static swig_type_info _swigt__p_lldb__SBBreakpointName = {"_p_lldb__SBBreakpointName", "lldb::SBBreakpointName *", 0, 0, (void*)&_wrap_class_SBBreakpointName, 0};
static swig_type_info _swigt__p_lldb__SBBroadcaster = {"_p_lldb__SBBroadcaster", "lldb::SBBroadcaster *", 0, 0, (void*)&_wrap_class_SBBroadcaster, 0};
static swig_type_info _swigt__p_lldb__SBCommandInterpreter = {"_p_lldb__SBCommandInterpreter", "lldb::SBCommandInterpreter *", 0, 0, (void*)&_wrap_class_SBCommandInterpreter, 0};
static swig_type_info _swigt__p_lldb__SBCommandInterpreterRunOptions = {"_p_lldb__SBCommandInterpreterRunOptions", "lldb::SBCommandInterpreterRunOptions *", 0, 0, (void*)&_wrap_class_SBCommandInterpreterRunOptions, 0};
static swig_type_info _swigt__p_lldb__SBCommandReturnObject = {"_p_lldb__SBCommandReturnObject", "lldb::SBCommandReturnObject *", 0, 0, (void*)&_wrap_class_SBCommandReturnObject, 0};
static swig_type_info _swigt__p_lldb__SBCommunication = {"_p_lldb__SBCommunication", "lldb::SBCommunication *", 0, 0, (void*)&_wrap_class_SBCommunication, 0};
static swig_type_info _swigt__p_lldb__SBCompileUnit = {"_p_lldb__SBCompileUnit", "lldb::SBCompileUnit *", 0, 0, (void*)&_wrap_class_SBCompileUnit, 0};
static swig_type_info _swigt__p_lldb__SBData = {"_p_lldb__SBData", "lldb::SBData *", 0, 0, (void*)&_wrap_class_SBData, 0};
static swig_type_info _swigt__p_lldb__SBDebugger = {"_p_lldb__SBDebugger", "lldb::SBDebugger *", 0, 0, (void*)&_wrap_class_SBDebugger, 0};
static swig_type_info _swigt__p_lldb__SBDeclaration = {"_p_lldb__SBDeclaration", "lldb::SBDeclaration *", 0, 0, (void*)&_wrap_class_SBDeclaration, 0};
static swig_type_info _swigt__p_lldb__SBEnvironment = {"_p_lldb__SBEnvironment", "lldb::SBEnvironment *", 0, 0, (void*)&_wrap_class_SBEnvironment, 0};
static swig_type_info _swigt__p_lldb__SBError = {"_p_lldb__SBError", "lldb::SBError *", 0, 0, (void*)&_wrap_class_SBError, 0};
static swig_type_info _swigt__p_lldb__SBEvent = {"_p_lldb__SBEvent", "lldb::SBEvent *", 0, 0, (void*)&_wrap_class_SBEvent, 0};
static swig_type_info _swigt__p_lldb__SBExecutionContext = {"_p_lldb__SBExecutionContext", "lldb::SBExecutionContext *", 0, 0, (void*)&_wrap_class_SBExecutionContext, 0};
static swig_type_info _swigt__p_lldb__SBExpressionOptions = {"_p_lldb__SBExpressionOptions", "lldb::SBExpressionOptions *", 0, 0, (void*)&_wrap_class_SBExpressionOptions, 0};
static swig_type_info _swigt__p_lldb__SBFile = {"_p_lldb__SBFile", "lldb::SBFile *", 0, 0, (void*)&_wrap_class_SBFile, 0};
static swig_type_info _swigt__p_lldb__SBFileSpec = {"_p_lldb__SBFileSpec", "lldb::SBFileSpec *", 0, 0, (void*)&_wrap_class_SBFileSpec, 0};
static swig_type_info _swigt__p_lldb__SBFileSpecList = {"_p_lldb__SBFileSpecList", "lldb::SBFileSpecList *", 0, 0, (void*)&_wrap_class_SBFileSpecList, 0};
static swig_type_info _swigt__p_lldb__SBFrame = {"_p_lldb__SBFrame", "lldb::SBFrame *", 0, 0, (void*)&_wrap_class_SBFrame, 0};
static swig_type_info _swigt__p_lldb__SBFunction = {"_p_lldb__SBFunction", "lldb::SBFunction *", 0, 0, (void*)&_wrap_class_SBFunction, 0};
static swig_type_info _swigt__p_lldb__SBHostOS = {"_p_lldb__SBHostOS", "lldb::SBHostOS *", 0, 0, (void*)&_wrap_class_SBHostOS, 0};
static swig_type_info _swigt__p_lldb__SBInstruction = {"_p_lldb__SBInstruction", "lldb::SBInstruction *", 0, 0, (void*)&_wrap_class_SBInstruction, 0};
static swig_type_info _swigt__p_lldb__SBInstructionList = {"_p_lldb__SBInstructionList", "lldb::SBInstructionList *", 0, 0, (void*)&_wrap_class_SBInstructionList, 0};
static swig_type_info _swigt__p_lldb__SBLanguageRuntime = {"_p_lldb__SBLanguageRuntime", "lldb::SBLanguageRuntime *", 0, 0, (void*)&_wrap_class_SBLanguageRuntime, 0};
static swig_type_info _swigt__p_lldb__SBLaunchInfo = {"_p_lldb__SBLaunchInfo", "lldb::SBLaunchInfo *", 0, 0, (void*)&_wrap_class_SBLaunchInfo, 0};
static swig_type_info _swigt__p_lldb__SBLineEntry = {"_p_lldb__SBLineEntry", "lldb::SBLineEntry *", 0, 0, (void*)&_wrap_class_SBLineEntry, 0};
static swig_type_info _swigt__p_lldb__SBListener = {"_p_lldb__SBListener", "lldb::SBListener *", 0, 0, (void*)&_wrap_class_SBListener, 0};
static swig_type_info _swigt__p_lldb__SBMemoryRegionInfo = {"_p_lldb__SBMemoryRegionInfo", "lldb::SBMemoryRegionInfo *", 0, 0, (void*)&_wrap_class_SBMemoryRegionInfo, 0};
static swig_type_info _swigt__p_lldb__SBMemoryRegionInfoList = {"_p_lldb__SBMemoryRegionInfoList", "lldb::SBMemoryRegionInfoList *", 0, 0, (void*)&_wrap_class_SBMemoryRegionInfoList, 0};
static swig_type_info _swigt__p_lldb__SBModule = {"_p_lldb__SBModule", "lldb::SBModule *", 0, 0, (void*)&_wrap_class_SBModule, 0};
static swig_type_info _swigt__p_lldb__SBModuleSpec = {"_p_lldb__SBModuleSpec", "lldb::SBModuleSpec *", 0, 0, (void*)&_wrap_class_SBModuleSpec, 0};
static swig_type_info _swigt__p_lldb__SBModuleSpecList = {"_p_lldb__SBModuleSpecList", "lldb::SBModuleSpecList *", 0, 0, (void*)&_wrap_class_SBModuleSpecList, 0};
static swig_type_info _swigt__p_lldb__SBPlatform = {"_p_lldb__SBPlatform", "lldb::SBPlatform *", 0, 0, (void*)&_wrap_class_SBPlatform, 0};
static swig_type_info _swigt__p_lldb__SBPlatformConnectOptions = {"_p_lldb__SBPlatformConnectOptions", "lldb::SBPlatformConnectOptions *", 0, 0, (void*)&_wrap_class_SBPlatformConnectOptions, 0};
static swig_type_info _swigt__p_lldb__SBPlatformShellCommand = {"_p_lldb__SBPlatformShellCommand", "lldb::SBPlatformShellCommand *", 0, 0, (void*)&_wrap_class_SBPlatformShellCommand, 0};
static swig_type_info _swigt__p_lldb__SBProcess = {"_p_lldb__SBProcess", "lldb::SBProcess *", 0, 0, (void*)&_wrap_class_SBProcess, 0};
static swig_type_info _swigt__p_lldb__SBProcessInfo = {"_p_lldb__SBProcessInfo", "lldb::SBProcessInfo *", 0, 0, (void*)&_wrap_class_SBProcessInfo, 0};
static swig_type_info _swigt__p_lldb__SBQueue = {"_p_lldb__SBQueue", "lldb::SBQueue *", 0, 0, (void*)&_wrap_class_SBQueue, 0};
static swig_type_info _swigt__p_lldb__SBQueueItem = {"_p_lldb__SBQueueItem", "lldb::SBQueueItem *", 0, 0, (void*)&_wrap_class_SBQueueItem, 0};
static swig_type_info _swigt__p_lldb__SBReproducer = {"_p_lldb__SBReproducer", "lldb::SBReproducer *", 0, 0, (void*)&_wrap_class_SBReproducer, 0};
static swig_type_info _swigt__p_lldb__SBSection = {"_p_lldb__SBSection", "lldb::SBSection *", 0, 0, (void*)&_wrap_class_SBSection, 0};
static swig_type_info _swigt__p_lldb__SBSourceManager = {"_p_lldb__SBSourceManager", "lldb::SBSourceManager *", 0, 0, (void*)&_wrap_class_SBSourceManager, 0};
static swig_type_info _swigt__p_lldb__SBStream = {"_p_lldb__SBStream", "lldb::SBStream *", 0, 0, (void*)&_wrap_class_SBStream, 0};
static swig_type_info _swigt__p_lldb__SBStringList = {"_p_lldb__SBStringList", "lldb::SBStringList *", 0, 0, (void*)&_wrap_class_SBStringList, 0};
static swig_type_info _swigt__p_lldb__SBStructuredData = {"_p_lldb__SBStructuredData", "lldb::SBStructuredData *", 0, 0, (void*)&_wrap_class_SBStructuredData, 0};
static swig_type_info _swigt__p_lldb__SBSymbol = {"_p_lldb__SBSymbol", "lldb::SBSymbol *", 0, 0, (void*)&_wrap_class_SBSymbol, 0};
static swig_type_info _swigt__p_lldb__SBSymbolContext = {"_p_lldb__SBSymbolContext", "lldb::SBSymbolContext *", 0, 0, (void*)&_wrap_class_SBSymbolContext, 0};
static swig_type_info _swigt__p_lldb__SBSymbolContextList = {"_p_lldb__SBSymbolContextList", "lldb::SBSymbolContextList *", 0, 0, (void*)&_wrap_class_SBSymbolContextList, 0};
static swig_type_info _swigt__p_lldb__SBTarget = {"_p_lldb__SBTarget", "lldb::SBTarget *", 0, 0, (void*)&_wrap_class_SBTarget, 0};
static swig_type_info _swigt__p_lldb__SBThread = {"_p_lldb__SBThread", "lldb::SBThread *", 0, 0, (void*)&_wrap_class_SBThread, 0};
static swig_type_info _swigt__p_lldb__SBThreadCollection = {"_p_lldb__SBThreadCollection", "lldb::SBThreadCollection *", 0, 0, (void*)&_wrap_class_SBThreadCollection, 0};
static swig_type_info _swigt__p_lldb__SBThreadPlan = {"_p_lldb__SBThreadPlan", "lldb::SBThreadPlan *", 0, 0, (void*)&_wrap_class_SBThreadPlan, 0};
static swig_type_info _swigt__p_lldb__SBTrace = {"_p_lldb__SBTrace", "lldb::SBTrace *", 0, 0, (void*)&_wrap_class_SBTrace, 0};
static swig_type_info _swigt__p_lldb__SBType = {"_p_lldb__SBType", "lldb::SBType *", 0, 0, (void*)&_wrap_class_SBType, 0};
static swig_type_info _swigt__p_lldb__SBTypeCategory = {"_p_lldb__SBTypeCategory", "lldb::SBTypeCategory *", 0, 0, (void*)&_wrap_class_SBTypeCategory, 0};
static swig_type_info _swigt__p_lldb__SBTypeEnumMember = {"_p_lldb__SBTypeEnumMember", "lldb::SBTypeEnumMember *", 0, 0, (void*)&_wrap_class_SBTypeEnumMember, 0};
static swig_type_info _swigt__p_lldb__SBTypeEnumMemberList = {"_p_lldb__SBTypeEnumMemberList", "lldb::SBTypeEnumMemberList *", 0, 0, (void*)&_wrap_class_SBTypeEnumMemberList, 0};
static swig_type_info _swigt__p_lldb__SBTypeFilter = {"_p_lldb__SBTypeFilter", "lldb::SBTypeFilter *", 0, 0, (void*)&_wrap_class_SBTypeFilter, 0};
static swig_type_info _swigt__p_lldb__SBTypeFormat = {"_p_lldb__SBTypeFormat", "lldb::SBTypeFormat *", 0, 0, (void*)&_wrap_class_SBTypeFormat, 0};
static swig_type_info _swigt__p_lldb__SBTypeList = {"_p_lldb__SBTypeList", "lldb::SBTypeList *", 0, 0, (void*)&_wrap_class_SBTypeList, 0};
static swig_type_info _swigt__p_lldb__SBTypeMember = {"_p_lldb__SBTypeMember", "lldb::SBTypeMember *", 0, 0, (void*)&_wrap_class_SBTypeMember, 0};
static swig_type_info _swigt__p_lldb__SBTypeMemberFunction = {"_p_lldb__SBTypeMemberFunction", "lldb::SBTypeMemberFunction *", 0, 0, (void*)&_wrap_class_SBTypeMemberFunction, 0};
static swig_type_info _swigt__p_lldb__SBTypeNameSpecifier = {"_p_lldb__SBTypeNameSpecifier", "lldb::SBTypeNameSpecifier *", 0, 0, (void*)&_wrap_class_SBTypeNameSpecifier, 0};
static swig_type_info _swigt__p_lldb__SBTypeSummary = {"_p_lldb__SBTypeSummary", "lldb::SBTypeSummary *", 0, 0, (void*)&_wrap_class_SBTypeSummary, 0};
static swig_type_info _swigt__p_lldb__SBTypeSummaryOptions = {"_p_lldb__SBTypeSummaryOptions", "lldb::SBTypeSummaryOptions *", 0, 0, (void*)&_wrap_class_SBTypeSummaryOptions, 0};
static swig_type_info _swigt__p_lldb__SBTypeSynthetic = {"_p_lldb__SBTypeSynthetic", "lldb::SBTypeSynthetic *", 0, 0, (void*)&_wrap_class_SBTypeSynthetic, 0};
static swig_type_info _swigt__p_lldb__SBUnixSignals = {"_p_lldb__SBUnixSignals", "lldb::SBUnixSignals *", 0, 0, (void*)&_wrap_class_SBUnixSignals, 0};
static swig_type_info _swigt__p_lldb__SBValue = {"_p_lldb__SBValue", "lldb::SBValue *", 0, 0, (void*)&_wrap_class_SBValue, 0};
static swig_type_info _swigt__p_lldb__SBValueList = {"_p_lldb__SBValueList", "lldb::SBValueList *", 0, 0, (void*)&_wrap_class_SBValueList, 0};
static swig_type_info _swigt__p_lldb__SBVariablesOptions = {"_p_lldb__SBVariablesOptions", "lldb::SBVariablesOptions *", 0, 0, (void*)&_wrap_class_SBVariablesOptions, 0};
static swig_type_info _swigt__p_lldb__SBWatchpoint = {"_p_lldb__SBWatchpoint", "lldb::SBWatchpoint *", 0, 0, (void*)&_wrap_class_SBWatchpoint, 0};
static swig_type_info _swigt__p_long_double = {"_p_long_double", "long double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_long = {"_p_long_long", "int_least64_t *|int_fast64_t *|int64_t *|long long *|intmax_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_void = {"_p_p_void", "lldb::thread_result_t *|void **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_pthread_rwlock_t = {"_p_pthread_rwlock_t", "pthread_rwlock_t *|lldb::rwlock_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_pthread_t = {"_p_pthread_t", "pthread_t *|lldb::thread_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ABI_t = {"_p_std__shared_ptrT_lldb_private__ABI_t", "std::shared_ptr< lldb_private::ABI > *|lldb::ABISP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Baton_t = {"_p_std__shared_ptrT_lldb_private__Baton_t", "lldb::BatonSP *|std::shared_ptr< lldb_private::Baton > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Block_t = {"_p_std__shared_ptrT_lldb_private__Block_t", "lldb::BlockSP *|std::shared_ptr< lldb_private::Block > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__BreakpointLocation_t = {"_p_std__shared_ptrT_lldb_private__BreakpointLocation_t", "lldb::BreakpointLocationSP *|std::shared_ptr< lldb_private::BreakpointLocation > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__BreakpointPrecondition_t = {"_p_std__shared_ptrT_lldb_private__BreakpointPrecondition_t", "std::shared_ptr< lldb_private::BreakpointPrecondition > *|lldb::BreakpointPreconditionSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__BreakpointResolver_t = {"_p_std__shared_ptrT_lldb_private__BreakpointResolver_t", "std::shared_ptr< lldb_private::BreakpointResolver > *|lldb::BreakpointResolverSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__BreakpointSite_t = {"_p_std__shared_ptrT_lldb_private__BreakpointSite_t", "std::shared_ptr< lldb_private::BreakpointSite > *|lldb::BreakpointSiteSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Breakpoint_t = {"_p_std__shared_ptrT_lldb_private__Breakpoint_t", "lldb::BreakpointSP *|std::shared_ptr< lldb_private::Breakpoint > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__BroadcasterManager_t = {"_p_std__shared_ptrT_lldb_private__BroadcasterManager_t", "lldb::BroadcasterManagerSP *|std::shared_ptr< lldb_private::BroadcasterManager > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Broadcaster_t = {"_p_std__shared_ptrT_lldb_private__Broadcaster_t", "std::shared_ptr< lldb_private::Broadcaster > *|lldb::BroadcasterSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__CommandObject_t = {"_p_std__shared_ptrT_lldb_private__CommandObject_t", "lldb::CommandObjectSP *|std::shared_ptr< lldb_private::CommandObject > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__CompileUnit_t = {"_p_std__shared_ptrT_lldb_private__CompileUnit_t", "lldb::CompUnitSP *|std::shared_ptr< lldb_private::CompileUnit > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Connection_t = {"_p_std__shared_ptrT_lldb_private__Connection_t", "lldb::ConnectionSP *|std::shared_ptr< lldb_private::Connection > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__DataBuffer_t = {"_p_std__shared_ptrT_lldb_private__DataBuffer_t", "std::shared_ptr< lldb_private::DataBuffer > *|lldb::DataBufferSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__DataExtractor_t = {"_p_std__shared_ptrT_lldb_private__DataExtractor_t", "std::shared_ptr< lldb_private::DataExtractor > *|lldb::DataExtractorSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Debugger_t = {"_p_std__shared_ptrT_lldb_private__Debugger_t", "std::shared_ptr< lldb_private::Debugger > *|lldb::DebuggerSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Disassembler_t = {"_p_std__shared_ptrT_lldb_private__Disassembler_t", "std::shared_ptr< lldb_private::Disassembler > *|lldb::DisassemblerSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__EventDataStructuredData_t = {"_p_std__shared_ptrT_lldb_private__EventDataStructuredData_t", "lldb::EventDataStructuredDataSP *|std::shared_ptr< lldb_private::EventDataStructuredData > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__EventData_t = {"_p_std__shared_ptrT_lldb_private__EventData_t", "lldb::EventDataSP *|std::shared_ptr< lldb_private::EventData > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Event_t = {"_p_std__shared_ptrT_lldb_private__Event_t", "lldb::EventSP *|std::shared_ptr< lldb_private::Event > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ExecutionContextRef_t = {"_p_std__shared_ptrT_lldb_private__ExecutionContextRef_t", "std::shared_ptr< lldb_private::ExecutionContextRef > *|lldb::ExecutionContextRefSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ExpressionVariable_t = {"_p_std__shared_ptrT_lldb_private__ExpressionVariable_t", "std::shared_ptr< lldb_private::ExpressionVariable > *|lldb::ExpressionVariableSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__File_t = {"_p_std__shared_ptrT_lldb_private__File_t", "lldb::FileSP *|std::shared_ptr< lldb_private::File > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__FuncUnwinders_t = {"_p_std__shared_ptrT_lldb_private__FuncUnwinders_t", "std::shared_ptr< lldb_private::FuncUnwinders > *|lldb::FuncUnwindersSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Function_t = {"_p_std__shared_ptrT_lldb_private__Function_t", "lldb::FunctionSP *|std::shared_ptr< lldb_private::Function > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__IOHandler_t = {"_p_std__shared_ptrT_lldb_private__IOHandler_t", "std::shared_ptr< lldb_private::IOHandler > *|lldb::IOHandlerSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__IOObject_t = {"_p_std__shared_ptrT_lldb_private__IOObject_t", "lldb::IOObjectSP *|std::shared_ptr< lldb_private::IOObject > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__IRExecutionUnit_t = {"_p_std__shared_ptrT_lldb_private__IRExecutionUnit_t", "lldb::IRExecutionUnitSP *|std::shared_ptr< lldb_private::IRExecutionUnit > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__InlineFunctionInfo_t = {"_p_std__shared_ptrT_lldb_private__InlineFunctionInfo_t", "lldb::InlineFunctionInfoSP *|std::shared_ptr< lldb_private::InlineFunctionInfo > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Instruction_t = {"_p_std__shared_ptrT_lldb_private__Instruction_t", "lldb::InstructionSP *|std::shared_ptr< lldb_private::Instruction > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__InstrumentationRuntime_t = {"_p_std__shared_ptrT_lldb_private__InstrumentationRuntime_t", "lldb::InstrumentationRuntimeSP *|std::shared_ptr< lldb_private::InstrumentationRuntime > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__JITLoader_t = {"_p_std__shared_ptrT_lldb_private__JITLoader_t", "std::shared_ptr< lldb_private::JITLoader > *|lldb::JITLoaderSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__LanguageRuntime_t = {"_p_std__shared_ptrT_lldb_private__LanguageRuntime_t", "std::shared_ptr< lldb_private::LanguageRuntime > *|lldb::LanguageRuntimeSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Listener_t = {"_p_std__shared_ptrT_lldb_private__Listener_t", "std::shared_ptr< lldb_private::Listener > *|lldb::ListenerSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__MemoryHistory_t = {"_p_std__shared_ptrT_lldb_private__MemoryHistory_t", "lldb::MemoryHistorySP *|std::shared_ptr< lldb_private::MemoryHistory > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t = {"_p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t", "std::shared_ptr< lldb_private::MemoryRegionInfo > *|lldb::MemoryRegionInfoSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Module_t = {"_p_std__shared_ptrT_lldb_private__Module_t", "lldb::ModuleSP *|std::shared_ptr< lldb_private::Module > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t = {"_p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t", "lldb::ObjectFileJITDelegateSP *|std::shared_ptr< lldb_private::ObjectFileJITDelegate > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ObjectFile_t = {"_p_std__shared_ptrT_lldb_private__ObjectFile_t", "lldb::ObjectFileSP *|std::shared_ptr< lldb_private::ObjectFile > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__OptionValueProperties_t = {"_p_std__shared_ptrT_lldb_private__OptionValueProperties_t", "lldb::OptionValuePropertiesSP *|std::shared_ptr< lldb_private::OptionValueProperties > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__OptionValue_t = {"_p_std__shared_ptrT_lldb_private__OptionValue_t", "std::shared_ptr< lldb_private::OptionValue > *|lldb::OptionValueSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Platform_t = {"_p_std__shared_ptrT_lldb_private__Platform_t", "std::shared_ptr< lldb_private::Platform > *|lldb::PlatformSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t = {"_p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t", "lldb::ProcessAttachInfoSP *|std::shared_ptr< lldb_private::ProcessAttachInfo > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Process_t = {"_p_std__shared_ptrT_lldb_private__Process_t", "lldb::ProcessSP *|std::shared_ptr< lldb_private::Process > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__QueueItem_t = {"_p_std__shared_ptrT_lldb_private__QueueItem_t", "std::shared_ptr< lldb_private::QueueItem > *|lldb::QueueItemSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Queue_t = {"_p_std__shared_ptrT_lldb_private__Queue_t", "std::shared_ptr< lldb_private::Queue > *|lldb::QueueSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__REPL_t = {"_p_std__shared_ptrT_lldb_private__REPL_t", "lldb::REPLSP *|std::shared_ptr< lldb_private::REPL > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__RecognizedStackFrame_t = {"_p_std__shared_ptrT_lldb_private__RecognizedStackFrame_t", "lldb::RecognizedStackFrameSP *|std::shared_ptr< lldb_private::RecognizedStackFrame > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t = {"_p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t", "std::shared_ptr< lldb_private::RegisterCheckpoint > *|lldb::RegisterCheckpointSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__RegisterContext_t = {"_p_std__shared_ptrT_lldb_private__RegisterContext_t", "lldb::RegisterContextSP *|std::shared_ptr< lldb_private::RegisterContext > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__RegularExpression_t = {"_p_std__shared_ptrT_lldb_private__RegularExpression_t", "lldb::RegularExpressionSP *|std::shared_ptr< lldb_private::RegularExpression > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptInterpreter_t = {"_p_std__shared_ptrT_lldb_private__ScriptInterpreter_t", "std::shared_ptr< lldb_private::ScriptInterpreter > *|lldb::ScriptInterpreterSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t = {"_p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t", "lldb::ScriptSummaryFormatSP *|std::shared_ptr< lldb_private::ScriptSummaryFormat > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t = {"_p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t", "std::shared_ptr< lldb_private::ScriptedSyntheticChildren > *|lldb::ScriptedSyntheticChildrenSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptedThreadInterface_t = {"_p_std__shared_ptrT_lldb_private__ScriptedThreadInterface_t", "lldb::ScriptedThreadInterfaceSP *|std::shared_ptr< lldb_private::ScriptedThreadInterface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__SearchFilter_t = {"_p_std__shared_ptrT_lldb_private__SearchFilter_t", "std::shared_ptr< lldb_private::SearchFilter > *|lldb::SearchFilterSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__SectionLoadList_t = {"_p_std__shared_ptrT_lldb_private__SectionLoadList_t", "std::shared_ptr< lldb_private::SectionLoadList > *|lldb::SectionLoadListSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Section_t = {"_p_std__shared_ptrT_lldb_private__Section_t", "lldb::SectionSP *|std::shared_ptr< lldb_private::Section > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__StackFrameList_t = {"_p_std__shared_ptrT_lldb_private__StackFrameList_t", "std::shared_ptr< lldb_private::StackFrameList > *|lldb::StackFrameListSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__StackFrameRecognizer_t = {"_p_std__shared_ptrT_lldb_private__StackFrameRecognizer_t", "std::shared_ptr< lldb_private::StackFrameRecognizer > *|lldb::StackFrameRecognizerSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__StackFrame_t = {"_p_std__shared_ptrT_lldb_private__StackFrame_t", "std::shared_ptr< lldb_private::StackFrame > *|lldb::StackFrameSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__StopInfo_t = {"_p_std__shared_ptrT_lldb_private__StopInfo_t", "lldb::StopInfoSP *|std::shared_ptr< lldb_private::StopInfo > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__StreamFile_t = {"_p_std__shared_ptrT_lldb_private__StreamFile_t", "lldb::StreamFileSP *|std::shared_ptr< lldb_private::StreamFile > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Stream_t = {"_p_std__shared_ptrT_lldb_private__Stream_t", "std::shared_ptr< lldb_private::Stream > *|lldb::StreamSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__StringSummaryFormat_t = {"_p_std__shared_ptrT_lldb_private__StringSummaryFormat_t", "lldb::StringTypeSummaryImplSP *|std::shared_ptr< lldb_private::StringSummaryFormat > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t = {"_p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t", "lldb::StructuredDataPluginSP *|std::shared_ptr< lldb_private::StructuredDataPlugin > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t = {"_p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t", "lldb::SymbolContextSpecifierSP *|std::shared_ptr< lldb_private::SymbolContextSpecifier > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__SymbolFileType_t = {"_p_std__shared_ptrT_lldb_private__SymbolFileType_t", "lldb::SymbolFileTypeSP *|std::shared_ptr< lldb_private::SymbolFileType > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t = {"_p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t", "lldb::SyntheticChildrenFrontEndSP *|std::shared_ptr< lldb_private::SyntheticChildrenFrontEnd > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__SyntheticChildren_t = {"_p_std__shared_ptrT_lldb_private__SyntheticChildren_t", "std::shared_ptr< lldb_private::SyntheticChildren > *|lldb::SyntheticChildrenSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Target_t = {"_p_std__shared_ptrT_lldb_private__Target_t", "std::shared_ptr< lldb_private::Target > *|lldb::TargetSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ThreadCollection_t = {"_p_std__shared_ptrT_lldb_private__ThreadCollection_t", "std::shared_ptr< lldb_private::ThreadCollection > *|lldb::ThreadCollectionSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t = {"_p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t", "std::shared_ptr< lldb_private::ThreadPlanTracer > *|lldb::ThreadPlanTracerSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ThreadPlan_t = {"_p_std__shared_ptrT_lldb_private__ThreadPlan_t", "lldb::ThreadPlanSP *|std::shared_ptr< lldb_private::ThreadPlan > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ThreadPostMortemTrace_t = {"_p_std__shared_ptrT_lldb_private__ThreadPostMortemTrace_t", "std::shared_ptr< lldb_private::ThreadPostMortemTrace > *|lldb::ThreadPostMortemTraceSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Thread_t = {"_p_std__shared_ptrT_lldb_private__Thread_t", "std::shared_ptr< lldb_private::Thread > *|lldb::ThreadSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Trace_t = {"_p_std__shared_ptrT_lldb_private__Trace_t", "std::shared_ptr< lldb_private::Trace > *|lldb::TraceSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t = {"_p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t", "std::shared_ptr< lldb_private::TypeCategoryImpl > *|lldb::TypeCategoryImplSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t = {"_p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t", "lldb::TypeEnumMemberImplSP *|std::shared_ptr< lldb_private::TypeEnumMemberImpl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeFilterImpl_t = {"_p_std__shared_ptrT_lldb_private__TypeFilterImpl_t", "lldb::TypeFilterImplSP *|std::shared_ptr< lldb_private::TypeFilterImpl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeFormatImpl_t = {"_p_std__shared_ptrT_lldb_private__TypeFormatImpl_t", "lldb::TypeFormatImplSP *|std::shared_ptr< lldb_private::TypeFormatImpl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeImpl_t = {"_p_std__shared_ptrT_lldb_private__TypeImpl_t", "lldb::TypeImplSP *|std::shared_ptr< lldb_private::TypeImpl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t = {"_p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t", "std::shared_ptr< lldb_private::TypeMemberFunctionImpl > *|lldb::TypeMemberFunctionImplSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t = {"_p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t", "std::shared_ptr< lldb_private::TypeNameSpecifierImpl > *|lldb::TypeNameSpecifierImplSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t = {"_p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t", "lldb::TypeSummaryImplSP *|std::shared_ptr< lldb_private::TypeSummaryImpl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t = {"_p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t", "std::shared_ptr< lldb_private::TypeSummaryOptions > *|lldb::TypeSummaryOptionsSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeSystem_t = {"_p_std__shared_ptrT_lldb_private__TypeSystem_t", "std::shared_ptr< lldb_private::TypeSystem > *|lldb::TypeSystemSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Type_t = {"_p_std__shared_ptrT_lldb_private__Type_t", "lldb::TypeSP *|std::shared_ptr< lldb_private::Type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__UnixSignals_t = {"_p_std__shared_ptrT_lldb_private__UnixSignals_t", "lldb::UnixSignalsSP *|std::shared_ptr< lldb_private::UnixSignals > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__UnwindAssembly_t = {"_p_std__shared_ptrT_lldb_private__UnwindAssembly_t", "std::shared_ptr< lldb_private::UnwindAssembly > *|lldb::UnwindAssemblySP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__UnwindPlan_t = {"_p_std__shared_ptrT_lldb_private__UnwindPlan_t", "lldb::UnwindPlanSP *|std::shared_ptr< lldb_private::UnwindPlan > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__UserExpression_t = {"_p_std__shared_ptrT_lldb_private__UserExpression_t", "lldb::UserExpressionSP *|std::shared_ptr< lldb_private::UserExpression > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ValueObjectList_t = {"_p_std__shared_ptrT_lldb_private__ValueObjectList_t", "std::shared_ptr< lldb_private::ValueObjectList > *|lldb::ValueObjectListSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ValueObject_t = {"_p_std__shared_ptrT_lldb_private__ValueObject_t", "lldb::ValueObjectSP *|std::shared_ptr< lldb_private::ValueObject > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Value_t = {"_p_std__shared_ptrT_lldb_private__Value_t", "std::shared_ptr< lldb_private::Value > *|lldb::ValueSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__VariableList_t = {"_p_std__shared_ptrT_lldb_private__VariableList_t", "std::shared_ptr< lldb_private::VariableList > *|lldb::VariableListSP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Variable_t = {"_p_std__shared_ptrT_lldb_private__Variable_t", "lldb::VariableSP *|std::shared_ptr< lldb_private::Variable > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Watchpoint_t = {"_p_std__shared_ptrT_lldb_private__Watchpoint_t", "lldb::WatchpointSP *|std::shared_ptr< lldb_private::Watchpoint > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)&_wrap_class_string, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t = {"_p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t", "lldb::DynamicCheckerFunctionsUP *|std::unique_ptr< lldb_private::DynamicCheckerFunctions > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__DynamicLoader_t = {"_p_std__unique_ptrT_lldb_private__DynamicLoader_t", "lldb::DynamicLoaderUP *|std::unique_ptr< lldb_private::DynamicLoader > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__File_t = {"_p_std__unique_ptrT_lldb_private__File_t", "lldb::FileUP *|std::unique_ptr< lldb_private::File > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__JITLoaderList_t = {"_p_std__unique_ptrT_lldb_private__JITLoaderList_t", "lldb::JITLoaderListUP *|std::unique_ptr< lldb_private::JITLoaderList > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t = {"_p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t", "std::unique_ptr< lldb_private::MemoryRegionInfo > *|lldb::MemoryRegionInfoUP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__OperatingSystem_t = {"_p_std__unique_ptrT_lldb_private__OperatingSystem_t", "lldb::OperatingSystemUP *|std::unique_ptr< lldb_private::OperatingSystem > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__ScriptedProcessInterface_t = {"_p_std__unique_ptrT_lldb_private__ScriptedProcessInterface_t", "std::unique_ptr< lldb_private::ScriptedProcessInterface > *|lldb::ScriptedProcessInterfaceUP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__SectionList_t = {"_p_std__unique_ptrT_lldb_private__SectionList_t", "lldb::SectionListUP *|std::unique_ptr< lldb_private::SectionList > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__SourceManager_t = {"_p_std__unique_ptrT_lldb_private__SourceManager_t", "std::unique_ptr< lldb_private::SourceManager > *|lldb::SourceManagerUP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__StackFrameRecognizerManager_t = {"_p_std__unique_ptrT_lldb_private__StackFrameRecognizerManager_t", "std::unique_ptr< lldb_private::StackFrameRecognizerManager > *|lldb::StackFrameRecognizerManagerUP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__StructuredDataImpl_t = {"_p_std__unique_ptrT_lldb_private__StructuredDataImpl_t", "std::unique_ptr< lldb_private::StructuredDataImpl > *|lldb::StructuredDataImplUP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__SymbolVendor_t = {"_p_std__unique_ptrT_lldb_private__SymbolVendor_t", "std::unique_ptr< lldb_private::SymbolVendor > *|lldb::SymbolVendorUP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__SystemRuntime_t = {"_p_std__unique_ptrT_lldb_private__SystemRuntime_t", "std::unique_ptr< lldb_private::SystemRuntime > *|lldb::SystemRuntimeUP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__TraceCursor_t = {"_p_std__unique_ptrT_lldb_private__TraceCursor_t", "std::unique_ptr< lldb_private::TraceCursor > *|lldb::TraceCursorUP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__TraceExporter_t = {"_p_std__unique_ptrT_lldb_private__TraceExporter_t", "lldb::TraceExporterUP *|std::unique_ptr< lldb_private::TraceExporter > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__BreakpointLocation_t = {"_p_std__weak_ptrT_lldb_private__BreakpointLocation_t", "std::weak_ptr< lldb_private::BreakpointLocation > *|lldb::BreakpointLocationWP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Breakpoint_t = {"_p_std__weak_ptrT_lldb_private__Breakpoint_t", "std::weak_ptr< lldb_private::Breakpoint > *|lldb::BreakpointWP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__BroadcasterManager_t = {"_p_std__weak_ptrT_lldb_private__BroadcasterManager_t", "std::weak_ptr< lldb_private::BroadcasterManager > *|lldb::BroadcasterManagerWP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Debugger_t = {"_p_std__weak_ptrT_lldb_private__Debugger_t", "std::weak_ptr< lldb_private::Debugger > *|lldb::DebuggerWP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Listener_t = {"_p_std__weak_ptrT_lldb_private__Listener_t", "std::weak_ptr< lldb_private::Listener > *|lldb::ListenerWP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Module_t = {"_p_std__weak_ptrT_lldb_private__Module_t", "std::weak_ptr< lldb_private::Module > *|lldb::ModuleWP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t = {"_p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t", "lldb::ObjectFileJITDelegateWP *|std::weak_ptr< lldb_private::ObjectFileJITDelegate > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__OptionValue_t = {"_p_std__weak_ptrT_lldb_private__OptionValue_t", "std::weak_ptr< lldb_private::OptionValue > *|lldb::OptionValueWP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Process_t = {"_p_std__weak_ptrT_lldb_private__Process_t", "std::weak_ptr< lldb_private::Process > *|lldb::ProcessWP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Queue_t = {"_p_std__weak_ptrT_lldb_private__Queue_t", "std::weak_ptr< lldb_private::Queue > *|lldb::QueueWP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Section_t = {"_p_std__weak_ptrT_lldb_private__Section_t", "std::weak_ptr< lldb_private::Section > *|lldb::SectionWP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__StackFrame_t = {"_p_std__weak_ptrT_lldb_private__StackFrame_t", "std::weak_ptr< lldb_private::StackFrame > *|lldb::StackFrameWP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t = {"_p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t", "lldb::StructuredDataPluginWP *|std::weak_ptr< lldb_private::StructuredDataPlugin > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Target_t = {"_p_std__weak_ptrT_lldb_private__Target_t", "std::weak_ptr< lldb_private::Target > *|lldb::TargetWP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__ThreadPlan_t = {"_p_std__weak_ptrT_lldb_private__ThreadPlan_t", "std::weak_ptr< lldb_private::ThreadPlan > *|lldb::ThreadPlanWP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Thread_t = {"_p_std__weak_ptrT_lldb_private__Thread_t", "std::weak_ptr< lldb_private::Thread > *|lldb::ThreadWP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Type_t = {"_p_std__weak_ptrT_lldb_private__Type_t", "std::weak_ptr< lldb_private::Type > *|lldb::TypeWP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__UnixSignals_t = {"_p_std__weak_ptrT_lldb_private__UnixSignals_t", "std::weak_ptr< lldb_private::UnixSignals > *|lldb::UnixSignalsWP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|uint_least8_t *|uint_fast8_t *|uint8_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uintptr_t *|uint_least32_t *|uint_fast32_t *|uint32_t *|unsigned int *|uint_fast16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint_least64_t *|uint_fast64_t *|uint64_t *|lldb::process_t *|unsigned long long *|lldb::addr_t *|lldb::offset_t *|lldb::queue_id_t *|lldb::user_id_t *|lldb::pid_t *|uintmax_t *|lldb::tid_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
&_swigt__p_bool,
&_swigt__p_double,
&_swigt__p_f_p_q_const__char_p_void__void,
&_swigt__p_f_p_void__p_void,
&_swigt__p_f_p_void_p_q_const__void_size_t__void,
&_swigt__p_int,
&_swigt__p_lldb__ConnectionStatus,
&_swigt__p_lldb__SBAddress,
&_swigt__p_lldb__SBAttachInfo,
&_swigt__p_lldb__SBBlock,
&_swigt__p_lldb__SBBreakpoint,
&_swigt__p_lldb__SBBreakpointList,
&_swigt__p_lldb__SBBreakpointLocation,
&_swigt__p_lldb__SBBreakpointName,
&_swigt__p_lldb__SBBroadcaster,
&_swigt__p_lldb__SBCommandInterpreter,
&_swigt__p_lldb__SBCommandInterpreterRunOptions,
&_swigt__p_lldb__SBCommandReturnObject,
&_swigt__p_lldb__SBCommunication,
&_swigt__p_lldb__SBCompileUnit,
&_swigt__p_lldb__SBData,
&_swigt__p_lldb__SBDebugger,
&_swigt__p_lldb__SBDeclaration,
&_swigt__p_lldb__SBEnvironment,
&_swigt__p_lldb__SBError,
&_swigt__p_lldb__SBEvent,
&_swigt__p_lldb__SBExecutionContext,
&_swigt__p_lldb__SBExpressionOptions,
&_swigt__p_lldb__SBFile,
&_swigt__p_lldb__SBFileSpec,
&_swigt__p_lldb__SBFileSpecList,
&_swigt__p_lldb__SBFrame,
&_swigt__p_lldb__SBFunction,
&_swigt__p_lldb__SBHostOS,
&_swigt__p_lldb__SBInstruction,
&_swigt__p_lldb__SBInstructionList,
&_swigt__p_lldb__SBLanguageRuntime,
&_swigt__p_lldb__SBLaunchInfo,
&_swigt__p_lldb__SBLineEntry,
&_swigt__p_lldb__SBListener,
&_swigt__p_lldb__SBMemoryRegionInfo,
&_swigt__p_lldb__SBMemoryRegionInfoList,
&_swigt__p_lldb__SBModule,
&_swigt__p_lldb__SBModuleSpec,
&_swigt__p_lldb__SBModuleSpecList,
&_swigt__p_lldb__SBPlatform,
&_swigt__p_lldb__SBPlatformConnectOptions,
&_swigt__p_lldb__SBPlatformShellCommand,
&_swigt__p_lldb__SBProcess,
&_swigt__p_lldb__SBProcessInfo,
&_swigt__p_lldb__SBQueue,
&_swigt__p_lldb__SBQueueItem,
&_swigt__p_lldb__SBReproducer,
&_swigt__p_lldb__SBSection,
&_swigt__p_lldb__SBSourceManager,
&_swigt__p_lldb__SBStream,
&_swigt__p_lldb__SBStringList,
&_swigt__p_lldb__SBStructuredData,
&_swigt__p_lldb__SBSymbol,
&_swigt__p_lldb__SBSymbolContext,
&_swigt__p_lldb__SBSymbolContextList,
&_swigt__p_lldb__SBTarget,
&_swigt__p_lldb__SBThread,
&_swigt__p_lldb__SBThreadCollection,
&_swigt__p_lldb__SBThreadPlan,
&_swigt__p_lldb__SBTrace,
&_swigt__p_lldb__SBType,
&_swigt__p_lldb__SBTypeCategory,
&_swigt__p_lldb__SBTypeEnumMember,
&_swigt__p_lldb__SBTypeEnumMemberList,
&_swigt__p_lldb__SBTypeFilter,
&_swigt__p_lldb__SBTypeFormat,
&_swigt__p_lldb__SBTypeList,
&_swigt__p_lldb__SBTypeMember,
&_swigt__p_lldb__SBTypeMemberFunction,
&_swigt__p_lldb__SBTypeNameSpecifier,
&_swigt__p_lldb__SBTypeSummary,
&_swigt__p_lldb__SBTypeSummaryOptions,
&_swigt__p_lldb__SBTypeSynthetic,
&_swigt__p_lldb__SBUnixSignals,
&_swigt__p_lldb__SBValue,
&_swigt__p_lldb__SBValueList,
&_swigt__p_lldb__SBVariablesOptions,
&_swigt__p_lldb__SBWatchpoint,
&_swigt__p_long_double,
&_swigt__p_long_long,
&_swigt__p_p_void,
&_swigt__p_pthread_rwlock_t,
&_swigt__p_pthread_t,
&_swigt__p_short,
&_swigt__p_signed_char,
&_swigt__p_size_t,
&_swigt__p_std__shared_ptrT_lldb_private__ABI_t,
&_swigt__p_std__shared_ptrT_lldb_private__Baton_t,
&_swigt__p_std__shared_ptrT_lldb_private__Block_t,
&_swigt__p_std__shared_ptrT_lldb_private__BreakpointLocation_t,
&_swigt__p_std__shared_ptrT_lldb_private__BreakpointPrecondition_t,
&_swigt__p_std__shared_ptrT_lldb_private__BreakpointResolver_t,
&_swigt__p_std__shared_ptrT_lldb_private__BreakpointSite_t,
&_swigt__p_std__shared_ptrT_lldb_private__Breakpoint_t,
&_swigt__p_std__shared_ptrT_lldb_private__BroadcasterManager_t,
&_swigt__p_std__shared_ptrT_lldb_private__Broadcaster_t,
&_swigt__p_std__shared_ptrT_lldb_private__CommandObject_t,
&_swigt__p_std__shared_ptrT_lldb_private__CompileUnit_t,
&_swigt__p_std__shared_ptrT_lldb_private__Connection_t,
&_swigt__p_std__shared_ptrT_lldb_private__DataBuffer_t,
&_swigt__p_std__shared_ptrT_lldb_private__DataExtractor_t,
&_swigt__p_std__shared_ptrT_lldb_private__Debugger_t,
&_swigt__p_std__shared_ptrT_lldb_private__Disassembler_t,
&_swigt__p_std__shared_ptrT_lldb_private__EventDataStructuredData_t,
&_swigt__p_std__shared_ptrT_lldb_private__EventData_t,
&_swigt__p_std__shared_ptrT_lldb_private__Event_t,
&_swigt__p_std__shared_ptrT_lldb_private__ExecutionContextRef_t,
&_swigt__p_std__shared_ptrT_lldb_private__ExpressionVariable_t,
&_swigt__p_std__shared_ptrT_lldb_private__File_t,
&_swigt__p_std__shared_ptrT_lldb_private__FuncUnwinders_t,
&_swigt__p_std__shared_ptrT_lldb_private__Function_t,
&_swigt__p_std__shared_ptrT_lldb_private__IOHandler_t,
&_swigt__p_std__shared_ptrT_lldb_private__IOObject_t,
&_swigt__p_std__shared_ptrT_lldb_private__IRExecutionUnit_t,
&_swigt__p_std__shared_ptrT_lldb_private__InlineFunctionInfo_t,
&_swigt__p_std__shared_ptrT_lldb_private__Instruction_t,
&_swigt__p_std__shared_ptrT_lldb_private__InstrumentationRuntime_t,
&_swigt__p_std__shared_ptrT_lldb_private__JITLoader_t,
&_swigt__p_std__shared_ptrT_lldb_private__LanguageRuntime_t,
&_swigt__p_std__shared_ptrT_lldb_private__Listener_t,
&_swigt__p_std__shared_ptrT_lldb_private__MemoryHistory_t,
&_swigt__p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t,
&_swigt__p_std__shared_ptrT_lldb_private__Module_t,
&_swigt__p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t,
&_swigt__p_std__shared_ptrT_lldb_private__ObjectFile_t,
&_swigt__p_std__shared_ptrT_lldb_private__OptionValueProperties_t,
&_swigt__p_std__shared_ptrT_lldb_private__OptionValue_t,
&_swigt__p_std__shared_ptrT_lldb_private__Platform_t,
&_swigt__p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t,
&_swigt__p_std__shared_ptrT_lldb_private__Process_t,
&_swigt__p_std__shared_ptrT_lldb_private__QueueItem_t,
&_swigt__p_std__shared_ptrT_lldb_private__Queue_t,
&_swigt__p_std__shared_ptrT_lldb_private__REPL_t,
&_swigt__p_std__shared_ptrT_lldb_private__RecognizedStackFrame_t,
&_swigt__p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t,
&_swigt__p_std__shared_ptrT_lldb_private__RegisterContext_t,
&_swigt__p_std__shared_ptrT_lldb_private__RegularExpression_t,
&_swigt__p_std__shared_ptrT_lldb_private__ScriptInterpreter_t,
&_swigt__p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t,
&_swigt__p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t,
&_swigt__p_std__shared_ptrT_lldb_private__ScriptedThreadInterface_t,
&_swigt__p_std__shared_ptrT_lldb_private__SearchFilter_t,
&_swigt__p_std__shared_ptrT_lldb_private__SectionLoadList_t,
&_swigt__p_std__shared_ptrT_lldb_private__Section_t,
&_swigt__p_std__shared_ptrT_lldb_private__StackFrameList_t,
&_swigt__p_std__shared_ptrT_lldb_private__StackFrameRecognizer_t,
&_swigt__p_std__shared_ptrT_lldb_private__StackFrame_t,
&_swigt__p_std__shared_ptrT_lldb_private__StopInfo_t,
&_swigt__p_std__shared_ptrT_lldb_private__StreamFile_t,
&_swigt__p_std__shared_ptrT_lldb_private__Stream_t,
&_swigt__p_std__shared_ptrT_lldb_private__StringSummaryFormat_t,
&_swigt__p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t,
&_swigt__p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t,
&_swigt__p_std__shared_ptrT_lldb_private__SymbolFileType_t,
&_swigt__p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t,
&_swigt__p_std__shared_ptrT_lldb_private__SyntheticChildren_t,
&_swigt__p_std__shared_ptrT_lldb_private__Target_t,
&_swigt__p_std__shared_ptrT_lldb_private__ThreadCollection_t,
&_swigt__p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t,
&_swigt__p_std__shared_ptrT_lldb_private__ThreadPlan_t,
&_swigt__p_std__shared_ptrT_lldb_private__ThreadPostMortemTrace_t,
&_swigt__p_std__shared_ptrT_lldb_private__Thread_t,
&_swigt__p_std__shared_ptrT_lldb_private__Trace_t,
&_swigt__p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t,
&_swigt__p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t,
&_swigt__p_std__shared_ptrT_lldb_private__TypeFilterImpl_t,
&_swigt__p_std__shared_ptrT_lldb_private__TypeFormatImpl_t,
&_swigt__p_std__shared_ptrT_lldb_private__TypeImpl_t,
&_swigt__p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t,
&_swigt__p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t,
&_swigt__p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t,
&_swigt__p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t,
&_swigt__p_std__shared_ptrT_lldb_private__TypeSystem_t,
&_swigt__p_std__shared_ptrT_lldb_private__Type_t,
&_swigt__p_std__shared_ptrT_lldb_private__UnixSignals_t,
&_swigt__p_std__shared_ptrT_lldb_private__UnwindAssembly_t,
&_swigt__p_std__shared_ptrT_lldb_private__UnwindPlan_t,
&_swigt__p_std__shared_ptrT_lldb_private__UserExpression_t,
&_swigt__p_std__shared_ptrT_lldb_private__ValueObjectList_t,
&_swigt__p_std__shared_ptrT_lldb_private__ValueObject_t,
&_swigt__p_std__shared_ptrT_lldb_private__Value_t,
&_swigt__p_std__shared_ptrT_lldb_private__VariableList_t,
&_swigt__p_std__shared_ptrT_lldb_private__Variable_t,
&_swigt__p_std__shared_ptrT_lldb_private__Watchpoint_t,
&_swigt__p_std__string,
&_swigt__p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t,
&_swigt__p_std__unique_ptrT_lldb_private__DynamicLoader_t,
&_swigt__p_std__unique_ptrT_lldb_private__File_t,
&_swigt__p_std__unique_ptrT_lldb_private__JITLoaderList_t,
&_swigt__p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t,
&_swigt__p_std__unique_ptrT_lldb_private__OperatingSystem_t,
&_swigt__p_std__unique_ptrT_lldb_private__ScriptedProcessInterface_t,
&_swigt__p_std__unique_ptrT_lldb_private__SectionList_t,
&_swigt__p_std__unique_ptrT_lldb_private__SourceManager_t,
&_swigt__p_std__unique_ptrT_lldb_private__StackFrameRecognizerManager_t,
&_swigt__p_std__unique_ptrT_lldb_private__StructuredDataImpl_t,
&_swigt__p_std__unique_ptrT_lldb_private__SymbolVendor_t,
&_swigt__p_std__unique_ptrT_lldb_private__SystemRuntime_t,
&_swigt__p_std__unique_ptrT_lldb_private__TraceCursor_t,
&_swigt__p_std__unique_ptrT_lldb_private__TraceExporter_t,
&_swigt__p_std__weak_ptrT_lldb_private__BreakpointLocation_t,
&_swigt__p_std__weak_ptrT_lldb_private__Breakpoint_t,
&_swigt__p_std__weak_ptrT_lldb_private__BroadcasterManager_t,
&_swigt__p_std__weak_ptrT_lldb_private__Debugger_t,
&_swigt__p_std__weak_ptrT_lldb_private__Listener_t,
&_swigt__p_std__weak_ptrT_lldb_private__Module_t,
&_swigt__p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t,
&_swigt__p_std__weak_ptrT_lldb_private__OptionValue_t,
&_swigt__p_std__weak_ptrT_lldb_private__Process_t,
&_swigt__p_std__weak_ptrT_lldb_private__Queue_t,
&_swigt__p_std__weak_ptrT_lldb_private__Section_t,
&_swigt__p_std__weak_ptrT_lldb_private__StackFrame_t,
&_swigt__p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t,
&_swigt__p_std__weak_ptrT_lldb_private__Target_t,
&_swigt__p_std__weak_ptrT_lldb_private__ThreadPlan_t,
&_swigt__p_std__weak_ptrT_lldb_private__Thread_t,
&_swigt__p_std__weak_ptrT_lldb_private__Type_t,
&_swigt__p_std__weak_ptrT_lldb_private__UnixSignals_t,
&_swigt__p_unsigned_char,
&_swigt__p_unsigned_int,
&_swigt__p_unsigned_long_long,
&_swigt__p_unsigned_short,
&_swigt__p_void,
};
static swig_cast_info _swigc__p_bool[] = { {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_void__void[] = { {&_swigt__p_f_p_q_const__char_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void__p_void[] = { {&_swigt__p_f_p_void__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__void_size_t__void[] = { {&_swigt__p_f_p_void_p_q_const__void_size_t__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__ConnectionStatus[] = { {&_swigt__p_lldb__ConnectionStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBAddress[] = { {&_swigt__p_lldb__SBAddress, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBAttachInfo[] = { {&_swigt__p_lldb__SBAttachInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBBlock[] = { {&_swigt__p_lldb__SBBlock, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBBreakpoint[] = { {&_swigt__p_lldb__SBBreakpoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBBreakpointList[] = { {&_swigt__p_lldb__SBBreakpointList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBBreakpointLocation[] = { {&_swigt__p_lldb__SBBreakpointLocation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBBreakpointName[] = { {&_swigt__p_lldb__SBBreakpointName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBBroadcaster[] = { {&_swigt__p_lldb__SBBroadcaster, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBCommandInterpreter[] = { {&_swigt__p_lldb__SBCommandInterpreter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBCommandInterpreterRunOptions[] = { {&_swigt__p_lldb__SBCommandInterpreterRunOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBCommandReturnObject[] = { {&_swigt__p_lldb__SBCommandReturnObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBCommunication[] = { {&_swigt__p_lldb__SBCommunication, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBCompileUnit[] = { {&_swigt__p_lldb__SBCompileUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBData[] = { {&_swigt__p_lldb__SBData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBDebugger[] = { {&_swigt__p_lldb__SBDebugger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBDeclaration[] = { {&_swigt__p_lldb__SBDeclaration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBEnvironment[] = { {&_swigt__p_lldb__SBEnvironment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBError[] = { {&_swigt__p_lldb__SBError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBEvent[] = { {&_swigt__p_lldb__SBEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBExecutionContext[] = { {&_swigt__p_lldb__SBExecutionContext, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBExpressionOptions[] = { {&_swigt__p_lldb__SBExpressionOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBFile[] = { {&_swigt__p_lldb__SBFile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBFileSpec[] = { {&_swigt__p_lldb__SBFileSpec, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBFileSpecList[] = { {&_swigt__p_lldb__SBFileSpecList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBFrame[] = { {&_swigt__p_lldb__SBFrame, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBFunction[] = { {&_swigt__p_lldb__SBFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBHostOS[] = { {&_swigt__p_lldb__SBHostOS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBInstruction[] = { {&_swigt__p_lldb__SBInstruction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBInstructionList[] = { {&_swigt__p_lldb__SBInstructionList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBLanguageRuntime[] = { {&_swigt__p_lldb__SBLanguageRuntime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBLaunchInfo[] = { {&_swigt__p_lldb__SBLaunchInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBLineEntry[] = { {&_swigt__p_lldb__SBLineEntry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBListener[] = { {&_swigt__p_lldb__SBListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBMemoryRegionInfo[] = { {&_swigt__p_lldb__SBMemoryRegionInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBMemoryRegionInfoList[] = { {&_swigt__p_lldb__SBMemoryRegionInfoList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBModule[] = { {&_swigt__p_lldb__SBModule, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBModuleSpec[] = { {&_swigt__p_lldb__SBModuleSpec, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBModuleSpecList[] = { {&_swigt__p_lldb__SBModuleSpecList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBPlatform[] = { {&_swigt__p_lldb__SBPlatform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBPlatformConnectOptions[] = { {&_swigt__p_lldb__SBPlatformConnectOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBPlatformShellCommand[] = { {&_swigt__p_lldb__SBPlatformShellCommand, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBProcess[] = { {&_swigt__p_lldb__SBProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBProcessInfo[] = { {&_swigt__p_lldb__SBProcessInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBQueue[] = { {&_swigt__p_lldb__SBQueue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBQueueItem[] = { {&_swigt__p_lldb__SBQueueItem, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBReproducer[] = { {&_swigt__p_lldb__SBReproducer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBSection[] = { {&_swigt__p_lldb__SBSection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBSourceManager[] = { {&_swigt__p_lldb__SBSourceManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBStream[] = { {&_swigt__p_lldb__SBStream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBStringList[] = { {&_swigt__p_lldb__SBStringList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBStructuredData[] = { {&_swigt__p_lldb__SBStructuredData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBSymbol[] = { {&_swigt__p_lldb__SBSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBSymbolContext[] = { {&_swigt__p_lldb__SBSymbolContext, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBSymbolContextList[] = { {&_swigt__p_lldb__SBSymbolContextList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTarget[] = { {&_swigt__p_lldb__SBTarget, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBThread[] = { {&_swigt__p_lldb__SBThread, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBThreadCollection[] = { {&_swigt__p_lldb__SBThreadCollection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBThreadPlan[] = { {&_swigt__p_lldb__SBThreadPlan, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTrace[] = { {&_swigt__p_lldb__SBTrace, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBType[] = { {&_swigt__p_lldb__SBType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeCategory[] = { {&_swigt__p_lldb__SBTypeCategory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeEnumMember[] = { {&_swigt__p_lldb__SBTypeEnumMember, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeEnumMemberList[] = { {&_swigt__p_lldb__SBTypeEnumMemberList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeFilter[] = { {&_swigt__p_lldb__SBTypeFilter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeFormat[] = { {&_swigt__p_lldb__SBTypeFormat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeList[] = { {&_swigt__p_lldb__SBTypeList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeMember[] = { {&_swigt__p_lldb__SBTypeMember, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeMemberFunction[] = { {&_swigt__p_lldb__SBTypeMemberFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeNameSpecifier[] = { {&_swigt__p_lldb__SBTypeNameSpecifier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeSummary[] = { {&_swigt__p_lldb__SBTypeSummary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeSummaryOptions[] = { {&_swigt__p_lldb__SBTypeSummaryOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeSynthetic[] = { {&_swigt__p_lldb__SBTypeSynthetic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBUnixSignals[] = { {&_swigt__p_lldb__SBUnixSignals, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBValue[] = { {&_swigt__p_lldb__SBValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBValueList[] = { {&_swigt__p_lldb__SBValueList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBVariablesOptions[] = { {&_swigt__p_lldb__SBVariablesOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBWatchpoint[] = { {&_swigt__p_lldb__SBWatchpoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_double[] = { {&_swigt__p_long_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_void[] = { {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_pthread_rwlock_t[] = { {&_swigt__p_pthread_rwlock_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_pthread_t[] = { {&_swigt__p_pthread_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_short[] = { {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_signed_char[] = { {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_size_t[] = { {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ABI_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ABI_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Baton_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Baton_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Block_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Block_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__BreakpointLocation_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__BreakpointLocation_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__BreakpointPrecondition_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__BreakpointPrecondition_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__BreakpointResolver_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__BreakpointResolver_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__BreakpointSite_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__BreakpointSite_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Breakpoint_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Breakpoint_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__BroadcasterManager_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__BroadcasterManager_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Broadcaster_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Broadcaster_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__CommandObject_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__CommandObject_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__CompileUnit_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__CompileUnit_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Connection_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Connection_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__DataBuffer_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__DataBuffer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__DataExtractor_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__DataExtractor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Debugger_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Debugger_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Disassembler_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Disassembler_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__EventDataStructuredData_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__EventDataStructuredData_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__EventData_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__EventData_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Event_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Event_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ExecutionContextRef_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ExecutionContextRef_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ExpressionVariable_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ExpressionVariable_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__File_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__File_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__FuncUnwinders_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__FuncUnwinders_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Function_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Function_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__IOHandler_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__IOHandler_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__IOObject_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__IOObject_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__IRExecutionUnit_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__IRExecutionUnit_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__InlineFunctionInfo_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__InlineFunctionInfo_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Instruction_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Instruction_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__InstrumentationRuntime_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__InstrumentationRuntime_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__JITLoader_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__JITLoader_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__LanguageRuntime_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__LanguageRuntime_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Listener_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Listener_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__MemoryHistory_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__MemoryHistory_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Module_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Module_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ObjectFile_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ObjectFile_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__OptionValueProperties_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__OptionValueProperties_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__OptionValue_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__OptionValue_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Platform_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Platform_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Process_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Process_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__QueueItem_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__QueueItem_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Queue_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Queue_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__REPL_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__REPL_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__RecognizedStackFrame_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__RecognizedStackFrame_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__RegisterContext_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__RegisterContext_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__RegularExpression_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__RegularExpression_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptInterpreter_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ScriptInterpreter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptedThreadInterface_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ScriptedThreadInterface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__SearchFilter_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__SearchFilter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__SectionLoadList_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__SectionLoadList_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Section_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Section_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__StackFrameList_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__StackFrameList_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__StackFrameRecognizer_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__StackFrameRecognizer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__StackFrame_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__StackFrame_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__StopInfo_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__StopInfo_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__StreamFile_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__StreamFile_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Stream_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Stream_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__StringSummaryFormat_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__StringSummaryFormat_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__SymbolFileType_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__SymbolFileType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__SyntheticChildren_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__SyntheticChildren_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Target_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Target_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ThreadCollection_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ThreadCollection_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ThreadPlan_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ThreadPlan_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ThreadPostMortemTrace_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ThreadPostMortemTrace_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Thread_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Thread_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Trace_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Trace_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeFilterImpl_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__TypeFilterImpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeFormatImpl_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__TypeFormatImpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeImpl_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__TypeImpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeSystem_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__TypeSystem_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Type_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__UnixSignals_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__UnixSignals_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__UnwindAssembly_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__UnwindAssembly_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__UnwindPlan_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__UnwindPlan_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__UserExpression_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__UserExpression_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ValueObjectList_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ValueObjectList_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ValueObject_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__ValueObject_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Value_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Value_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__VariableList_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__VariableList_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Variable_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Variable_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Watchpoint_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__Watchpoint_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__string[] = { {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t[] = { {&_swigt__p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__DynamicLoader_t[] = { {&_swigt__p_std__unique_ptrT_lldb_private__DynamicLoader_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__File_t[] = { {&_swigt__p_std__unique_ptrT_lldb_private__File_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__JITLoaderList_t[] = { {&_swigt__p_std__unique_ptrT_lldb_private__JITLoaderList_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t[] = { {&_swigt__p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__OperatingSystem_t[] = { {&_swigt__p_std__unique_ptrT_lldb_private__OperatingSystem_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__ScriptedProcessInterface_t[] = { {&_swigt__p_std__unique_ptrT_lldb_private__ScriptedProcessInterface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__SectionList_t[] = { {&_swigt__p_std__unique_ptrT_lldb_private__SectionList_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__SourceManager_t[] = { {&_swigt__p_std__unique_ptrT_lldb_private__SourceManager_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__StackFrameRecognizerManager_t[] = { {&_swigt__p_std__unique_ptrT_lldb_private__StackFrameRecognizerManager_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__StructuredDataImpl_t[] = { {&_swigt__p_std__unique_ptrT_lldb_private__StructuredDataImpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__SymbolVendor_t[] = { {&_swigt__p_std__unique_ptrT_lldb_private__SymbolVendor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__SystemRuntime_t[] = { {&_swigt__p_std__unique_ptrT_lldb_private__SystemRuntime_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__TraceCursor_t[] = { {&_swigt__p_std__unique_ptrT_lldb_private__TraceCursor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__TraceExporter_t[] = { {&_swigt__p_std__unique_ptrT_lldb_private__TraceExporter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__BreakpointLocation_t[] = { {&_swigt__p_std__weak_ptrT_lldb_private__BreakpointLocation_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Breakpoint_t[] = { {&_swigt__p_std__weak_ptrT_lldb_private__Breakpoint_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__BroadcasterManager_t[] = { {&_swigt__p_std__weak_ptrT_lldb_private__BroadcasterManager_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Debugger_t[] = { {&_swigt__p_std__weak_ptrT_lldb_private__Debugger_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Listener_t[] = { {&_swigt__p_std__weak_ptrT_lldb_private__Listener_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Module_t[] = { {&_swigt__p_std__weak_ptrT_lldb_private__Module_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t[] = { {&_swigt__p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__OptionValue_t[] = { {&_swigt__p_std__weak_ptrT_lldb_private__OptionValue_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Process_t[] = { {&_swigt__p_std__weak_ptrT_lldb_private__Process_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Queue_t[] = { {&_swigt__p_std__weak_ptrT_lldb_private__Queue_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Section_t[] = { {&_swigt__p_std__weak_ptrT_lldb_private__Section_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__StackFrame_t[] = { {&_swigt__p_std__weak_ptrT_lldb_private__StackFrame_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t[] = { {&_swigt__p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Target_t[] = { {&_swigt__p_std__weak_ptrT_lldb_private__Target_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__ThreadPlan_t[] = { {&_swigt__p_std__weak_ptrT_lldb_private__ThreadPlan_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Thread_t[] = { {&_swigt__p_std__weak_ptrT_lldb_private__Thread_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Type_t[] = { {&_swigt__p_std__weak_ptrT_lldb_private__Type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__UnixSignals_t[] = { {&_swigt__p_std__weak_ptrT_lldb_private__UnixSignals_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
_swigc__p_bool,
_swigc__p_double,
_swigc__p_f_p_q_const__char_p_void__void,
_swigc__p_f_p_void__p_void,
_swigc__p_f_p_void_p_q_const__void_size_t__void,
_swigc__p_int,
_swigc__p_lldb__ConnectionStatus,
_swigc__p_lldb__SBAddress,
_swigc__p_lldb__SBAttachInfo,
_swigc__p_lldb__SBBlock,
_swigc__p_lldb__SBBreakpoint,
_swigc__p_lldb__SBBreakpointList,
_swigc__p_lldb__SBBreakpointLocation,
_swigc__p_lldb__SBBreakpointName,
_swigc__p_lldb__SBBroadcaster,
_swigc__p_lldb__SBCommandInterpreter,
_swigc__p_lldb__SBCommandInterpreterRunOptions,
_swigc__p_lldb__SBCommandReturnObject,
_swigc__p_lldb__SBCommunication,
_swigc__p_lldb__SBCompileUnit,
_swigc__p_lldb__SBData,
_swigc__p_lldb__SBDebugger,
_swigc__p_lldb__SBDeclaration,
_swigc__p_lldb__SBEnvironment,
_swigc__p_lldb__SBError,
_swigc__p_lldb__SBEvent,
_swigc__p_lldb__SBExecutionContext,
_swigc__p_lldb__SBExpressionOptions,
_swigc__p_lldb__SBFile,
_swigc__p_lldb__SBFileSpec,
_swigc__p_lldb__SBFileSpecList,
_swigc__p_lldb__SBFrame,
_swigc__p_lldb__SBFunction,
_swigc__p_lldb__SBHostOS,
_swigc__p_lldb__SBInstruction,
_swigc__p_lldb__SBInstructionList,
_swigc__p_lldb__SBLanguageRuntime,
_swigc__p_lldb__SBLaunchInfo,
_swigc__p_lldb__SBLineEntry,
_swigc__p_lldb__SBListener,
_swigc__p_lldb__SBMemoryRegionInfo,
_swigc__p_lldb__SBMemoryRegionInfoList,
_swigc__p_lldb__SBModule,
_swigc__p_lldb__SBModuleSpec,
_swigc__p_lldb__SBModuleSpecList,
_swigc__p_lldb__SBPlatform,
_swigc__p_lldb__SBPlatformConnectOptions,
_swigc__p_lldb__SBPlatformShellCommand,
_swigc__p_lldb__SBProcess,
_swigc__p_lldb__SBProcessInfo,
_swigc__p_lldb__SBQueue,
_swigc__p_lldb__SBQueueItem,
_swigc__p_lldb__SBReproducer,
_swigc__p_lldb__SBSection,
_swigc__p_lldb__SBSourceManager,
_swigc__p_lldb__SBStream,
_swigc__p_lldb__SBStringList,
_swigc__p_lldb__SBStructuredData,
_swigc__p_lldb__SBSymbol,
_swigc__p_lldb__SBSymbolContext,
_swigc__p_lldb__SBSymbolContextList,
_swigc__p_lldb__SBTarget,
_swigc__p_lldb__SBThread,
_swigc__p_lldb__SBThreadCollection,
_swigc__p_lldb__SBThreadPlan,
_swigc__p_lldb__SBTrace,
_swigc__p_lldb__SBType,
_swigc__p_lldb__SBTypeCategory,
_swigc__p_lldb__SBTypeEnumMember,
_swigc__p_lldb__SBTypeEnumMemberList,
_swigc__p_lldb__SBTypeFilter,
_swigc__p_lldb__SBTypeFormat,
_swigc__p_lldb__SBTypeList,
_swigc__p_lldb__SBTypeMember,
_swigc__p_lldb__SBTypeMemberFunction,
_swigc__p_lldb__SBTypeNameSpecifier,
_swigc__p_lldb__SBTypeSummary,
_swigc__p_lldb__SBTypeSummaryOptions,
_swigc__p_lldb__SBTypeSynthetic,
_swigc__p_lldb__SBUnixSignals,
_swigc__p_lldb__SBValue,
_swigc__p_lldb__SBValueList,
_swigc__p_lldb__SBVariablesOptions,
_swigc__p_lldb__SBWatchpoint,
_swigc__p_long_double,
_swigc__p_long_long,
_swigc__p_p_void,
_swigc__p_pthread_rwlock_t,
_swigc__p_pthread_t,
_swigc__p_short,
_swigc__p_signed_char,
_swigc__p_size_t,
_swigc__p_std__shared_ptrT_lldb_private__ABI_t,
_swigc__p_std__shared_ptrT_lldb_private__Baton_t,
_swigc__p_std__shared_ptrT_lldb_private__Block_t,
_swigc__p_std__shared_ptrT_lldb_private__BreakpointLocation_t,
_swigc__p_std__shared_ptrT_lldb_private__BreakpointPrecondition_t,
_swigc__p_std__shared_ptrT_lldb_private__BreakpointResolver_t,
_swigc__p_std__shared_ptrT_lldb_private__BreakpointSite_t,
_swigc__p_std__shared_ptrT_lldb_private__Breakpoint_t,
_swigc__p_std__shared_ptrT_lldb_private__BroadcasterManager_t,
_swigc__p_std__shared_ptrT_lldb_private__Broadcaster_t,
_swigc__p_std__shared_ptrT_lldb_private__CommandObject_t,
_swigc__p_std__shared_ptrT_lldb_private__CompileUnit_t,
_swigc__p_std__shared_ptrT_lldb_private__Connection_t,
_swigc__p_std__shared_ptrT_lldb_private__DataBuffer_t,
_swigc__p_std__shared_ptrT_lldb_private__DataExtractor_t,
_swigc__p_std__shared_ptrT_lldb_private__Debugger_t,
_swigc__p_std__shared_ptrT_lldb_private__Disassembler_t,
_swigc__p_std__shared_ptrT_lldb_private__EventDataStructuredData_t,
_swigc__p_std__shared_ptrT_lldb_private__EventData_t,
_swigc__p_std__shared_ptrT_lldb_private__Event_t,
_swigc__p_std__shared_ptrT_lldb_private__ExecutionContextRef_t,
_swigc__p_std__shared_ptrT_lldb_private__ExpressionVariable_t,
_swigc__p_std__shared_ptrT_lldb_private__File_t,
_swigc__p_std__shared_ptrT_lldb_private__FuncUnwinders_t,
_swigc__p_std__shared_ptrT_lldb_private__Function_t,
_swigc__p_std__shared_ptrT_lldb_private__IOHandler_t,
_swigc__p_std__shared_ptrT_lldb_private__IOObject_t,
_swigc__p_std__shared_ptrT_lldb_private__IRExecutionUnit_t,
_swigc__p_std__shared_ptrT_lldb_private__InlineFunctionInfo_t,
_swigc__p_std__shared_ptrT_lldb_private__Instruction_t,
_swigc__p_std__shared_ptrT_lldb_private__InstrumentationRuntime_t,
_swigc__p_std__shared_ptrT_lldb_private__JITLoader_t,
_swigc__p_std__shared_ptrT_lldb_private__LanguageRuntime_t,
_swigc__p_std__shared_ptrT_lldb_private__Listener_t,
_swigc__p_std__shared_ptrT_lldb_private__MemoryHistory_t,
_swigc__p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t,
_swigc__p_std__shared_ptrT_lldb_private__Module_t,
_swigc__p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t,
_swigc__p_std__shared_ptrT_lldb_private__ObjectFile_t,
_swigc__p_std__shared_ptrT_lldb_private__OptionValueProperties_t,
_swigc__p_std__shared_ptrT_lldb_private__OptionValue_t,
_swigc__p_std__shared_ptrT_lldb_private__Platform_t,
_swigc__p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t,
_swigc__p_std__shared_ptrT_lldb_private__Process_t,
_swigc__p_std__shared_ptrT_lldb_private__QueueItem_t,
_swigc__p_std__shared_ptrT_lldb_private__Queue_t,
_swigc__p_std__shared_ptrT_lldb_private__REPL_t,
_swigc__p_std__shared_ptrT_lldb_private__RecognizedStackFrame_t,
_swigc__p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t,
_swigc__p_std__shared_ptrT_lldb_private__RegisterContext_t,
_swigc__p_std__shared_ptrT_lldb_private__RegularExpression_t,
_swigc__p_std__shared_ptrT_lldb_private__ScriptInterpreter_t,
_swigc__p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t,
_swigc__p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t,
_swigc__p_std__shared_ptrT_lldb_private__ScriptedThreadInterface_t,
_swigc__p_std__shared_ptrT_lldb_private__SearchFilter_t,
_swigc__p_std__shared_ptrT_lldb_private__SectionLoadList_t,
_swigc__p_std__shared_ptrT_lldb_private__Section_t,
_swigc__p_std__shared_ptrT_lldb_private__StackFrameList_t,
_swigc__p_std__shared_ptrT_lldb_private__StackFrameRecognizer_t,
_swigc__p_std__shared_ptrT_lldb_private__StackFrame_t,
_swigc__p_std__shared_ptrT_lldb_private__StopInfo_t,
_swigc__p_std__shared_ptrT_lldb_private__StreamFile_t,
_swigc__p_std__shared_ptrT_lldb_private__Stream_t,
_swigc__p_std__shared_ptrT_lldb_private__StringSummaryFormat_t,
_swigc__p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t,
_swigc__p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t,
_swigc__p_std__shared_ptrT_lldb_private__SymbolFileType_t,
_swigc__p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t,
_swigc__p_std__shared_ptrT_lldb_private__SyntheticChildren_t,
_swigc__p_std__shared_ptrT_lldb_private__Target_t,
_swigc__p_std__shared_ptrT_lldb_private__ThreadCollection_t,
_swigc__p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t,
_swigc__p_std__shared_ptrT_lldb_private__ThreadPlan_t,
_swigc__p_std__shared_ptrT_lldb_private__ThreadPostMortemTrace_t,
_swigc__p_std__shared_ptrT_lldb_private__Thread_t,
_swigc__p_std__shared_ptrT_lldb_private__Trace_t,
_swigc__p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t,
_swigc__p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t,
_swigc__p_std__shared_ptrT_lldb_private__TypeFilterImpl_t,
_swigc__p_std__shared_ptrT_lldb_private__TypeFormatImpl_t,
_swigc__p_std__shared_ptrT_lldb_private__TypeImpl_t,
_swigc__p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t,
_swigc__p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t,
_swigc__p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t,
_swigc__p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t,
_swigc__p_std__shared_ptrT_lldb_private__TypeSystem_t,
_swigc__p_std__shared_ptrT_lldb_private__Type_t,
_swigc__p_std__shared_ptrT_lldb_private__UnixSignals_t,
_swigc__p_std__shared_ptrT_lldb_private__UnwindAssembly_t,
_swigc__p_std__shared_ptrT_lldb_private__UnwindPlan_t,
_swigc__p_std__shared_ptrT_lldb_private__UserExpression_t,
_swigc__p_std__shared_ptrT_lldb_private__ValueObjectList_t,
_swigc__p_std__shared_ptrT_lldb_private__ValueObject_t,
_swigc__p_std__shared_ptrT_lldb_private__Value_t,
_swigc__p_std__shared_ptrT_lldb_private__VariableList_t,
_swigc__p_std__shared_ptrT_lldb_private__Variable_t,
_swigc__p_std__shared_ptrT_lldb_private__Watchpoint_t,
_swigc__p_std__string,
_swigc__p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t,
_swigc__p_std__unique_ptrT_lldb_private__DynamicLoader_t,
_swigc__p_std__unique_ptrT_lldb_private__File_t,
_swigc__p_std__unique_ptrT_lldb_private__JITLoaderList_t,
_swigc__p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t,
_swigc__p_std__unique_ptrT_lldb_private__OperatingSystem_t,
_swigc__p_std__unique_ptrT_lldb_private__ScriptedProcessInterface_t,
_swigc__p_std__unique_ptrT_lldb_private__SectionList_t,
_swigc__p_std__unique_ptrT_lldb_private__SourceManager_t,
_swigc__p_std__unique_ptrT_lldb_private__StackFrameRecognizerManager_t,
_swigc__p_std__unique_ptrT_lldb_private__StructuredDataImpl_t,
_swigc__p_std__unique_ptrT_lldb_private__SymbolVendor_t,
_swigc__p_std__unique_ptrT_lldb_private__SystemRuntime_t,
_swigc__p_std__unique_ptrT_lldb_private__TraceCursor_t,
_swigc__p_std__unique_ptrT_lldb_private__TraceExporter_t,
_swigc__p_std__weak_ptrT_lldb_private__BreakpointLocation_t,
_swigc__p_std__weak_ptrT_lldb_private__Breakpoint_t,
_swigc__p_std__weak_ptrT_lldb_private__BroadcasterManager_t,
_swigc__p_std__weak_ptrT_lldb_private__Debugger_t,
_swigc__p_std__weak_ptrT_lldb_private__Listener_t,
_swigc__p_std__weak_ptrT_lldb_private__Module_t,
_swigc__p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t,
_swigc__p_std__weak_ptrT_lldb_private__OptionValue_t,
_swigc__p_std__weak_ptrT_lldb_private__Process_t,
_swigc__p_std__weak_ptrT_lldb_private__Queue_t,
_swigc__p_std__weak_ptrT_lldb_private__Section_t,
_swigc__p_std__weak_ptrT_lldb_private__StackFrame_t,
_swigc__p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t,
_swigc__p_std__weak_ptrT_lldb_private__Target_t,
_swigc__p_std__weak_ptrT_lldb_private__ThreadPlan_t,
_swigc__p_std__weak_ptrT_lldb_private__Thread_t,
_swigc__p_std__weak_ptrT_lldb_private__Type_t,
_swigc__p_std__weak_ptrT_lldb_private__UnixSignals_t,
_swigc__p_unsigned_char,
_swigc__p_unsigned_int,
_swigc__p_unsigned_long_long,
_swigc__p_unsigned_short,
_swigc__p_void,
};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
/* -----------------------------------------------------------------------------
* Type initialization:
* This problem is tough by the requirement that no dynamic
* memory is used. Also, since swig_type_info structures store pointers to
* swig_cast_info structures and swig_cast_info structures store pointers back
* to swig_type_info structures, we need some lookup code at initialization.
* The idea is that swig generates all the structures that are needed.
* The runtime then collects these partially filled structures.
* The SWIG_InitializeModule function takes these initial arrays out of
* swig_module, and does all the lookup, filling in the swig_module.types
* array with the correct data and linking the correct swig_cast_info
* structures together.
*
* The generated swig_type_info structures are assigned statically to an initial
* array. We just loop through that array, and handle each type individually.
* First we lookup if this type has been already loaded, and if so, use the
* loaded structure instead of the generated one. Then we have to fill in the
* cast linked list. The cast data is initially stored in something like a
* two-dimensional array. Each row corresponds to a type (there are the same
* number of rows as there are in the swig_type_initial array). Each entry in
* a column is one of the swig_cast_info structures for that type.
* The cast_initial array is actually an array of arrays, because each row has
* a variable number of columns. So to actually build the cast linked list,
* we find the array of casts associated with the type, and loop through it
* adding the casts to the list. The one last trick we need to do is making
* sure the type pointer in the swig_cast_info struct is correct.
*
* First off, we lookup the cast->type name to see if it is already loaded.
* There are three cases to handle:
* 1) If the cast->type has already been loaded AND the type we are adding
* casting info to has not been loaded (it is in this module), THEN we
* replace the cast->type pointer with the type pointer that has already
* been loaded.
* 2) If BOTH types (the one we are adding casting info to, and the
* cast->type) are loaded, THEN the cast info has already been loaded by
* the previous module so we just ignore it.
* 3) Finally, if cast->type has not already been loaded, then we add that
* swig_cast_info to the linked list (because the cast->type) pointer will
* be correct.
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif
#if 0
#define SWIGRUNTIME_DEBUG
#endif
SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
size_t i;
swig_module_info *module_head, *iter;
int init;
/* check to see if the circular list has been setup, if not, set it up */
if (swig_module.next==0) {
/* Initialize the swig_module */
swig_module.type_initial = swig_type_initial;
swig_module.cast_initial = swig_cast_initial;
swig_module.next = &swig_module;
init = 1;
} else {
init = 0;
}
/* Try and load any already created modules */
module_head = SWIG_GetModule(clientdata);
if (!module_head) {
/* This is the first module loaded for this interpreter */
/* so set the swig module into the interpreter */
SWIG_SetModule(clientdata, &swig_module);
} else {
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
iter=module_head;
do {
if (iter==&swig_module) {
/* Our module is already in the list, so there's nothing more to do. */
return;
}
iter=iter->next;
} while (iter!= module_head);
/* otherwise we must add our module into the list */
swig_module.next = module_head->next;
module_head->next = &swig_module;
}
/* When multiple interpreters are used, a module could have already been initialized in
a different interpreter, but not yet have a pointer in this interpreter.
In this case, we do not want to continue adding types... everything should be
set up already */
if (init == 0) return;
/* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
for (i = 0; i < swig_module.size; ++i) {
swig_type_info *type = 0;
swig_type_info *ret;
swig_cast_info *cast;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
/* if there is another module already loaded */
if (swig_module.next != &swig_module) {
type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
}
if (type) {
/* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
if (swig_module.type_initial[i]->clientdata) {
type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
}
} else {
type = swig_module.type_initial[i];
}
/* Insert casting types */
cast = swig_module.cast_initial[i];
while (cast->type) {
/* Don't need to add information already in the list */
ret = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
if (swig_module.next != &swig_module) {
ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
}
if (ret) {
if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
cast->type = ret;
ret = 0;
} else {
/* Check for casting already in the list */
swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
if (!ocast) ret = 0;
}
}
if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
if (type->cast) {
type->cast->prev = cast;
cast->next = type->cast;
}
type->cast = cast;
}
cast++;
}
/* Set entry in modules->types array equal to the type */
swig_module.types[i] = type;
}
swig_module.types[i] = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("**** SWIG_InitializeModule: Cast List ******\n");
for (i = 0; i < swig_module.size; ++i) {
int j = 0;
swig_cast_info *cast = swig_module.cast_initial[i];
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
while (cast->type) {
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
cast++;
++j;
}
printf("---- Total casts: %d\n",j);
}
printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}
/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types. It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
size_t i;
swig_cast_info *equiv;
static int init_run = 0;
if (init_run) return;
init_run = 1;
for (i = 0; i < swig_module.size; i++) {
if (swig_module.types[i]->clientdata) {
equiv = swig_module.types[i]->cast;
while (equiv) {
if (!equiv->converter) {
if (equiv->type && !equiv->type->clientdata)
SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
}
equiv = equiv->next;
}
}
}
}
#ifdef __cplusplus
#if 0
{ /* c-mode */
#endif
}
#endif
/* Forward declaration of where the user's %init{} gets inserted */
void SWIG_init_user(lua_State* L );
#ifdef __cplusplus
extern "C" {
#endif
/* this is the initialization function
added at the very end of the code
the function is always called SWIG_init, but an earlier #define will rename it
*/
#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
LUALIB_API int SWIG_init(lua_State* L)
#else
SWIGEXPORT int SWIG_init(lua_State* L) /* default Lua action */
#endif
{
#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) /* valid for both Lua and eLua */
int i;
int globalRegister = 0;
/* start with global table */
lua_pushglobaltable (L);
/* SWIG's internal initialisation */
SWIG_InitializeModule((void*)L);
SWIG_PropagateClientData();
#endif
#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)) || defined(SWIG_LUA_ELUA_EMULATE)
/* add a global fn */
SWIG_Lua_add_function(L,"swig_type",SWIG_Lua_type);
SWIG_Lua_add_function(L,"swig_equals",SWIG_Lua_class_equal);
#endif
#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
/* set up base class pointers (the hierarchy) */
for (i = 0; swig_types[i]; i++){
if (swig_types[i]->clientdata){
SWIG_Lua_init_base_class(L,(swig_lua_class*)(swig_types[i]->clientdata));
}
}
#ifdef SWIG_LUA_MODULE_GLOBAL
globalRegister = 1;
#endif
#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
SWIG_Lua_namespace_register(L,&swig_SwigModule, globalRegister);
#endif
#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
for (i = 0; swig_types[i]; i++){
if (swig_types[i]->clientdata){
SWIG_Lua_elua_class_register_instance(L,(swig_lua_class*)(swig_types[i]->clientdata));
}
}
#endif
#if defined(SWIG_LUA_ELUA_EMULATE)
lua_newtable(L);
SWIG_Lua_elua_emulate_register(L,swig_SwigModule.ns_methods);
SWIG_Lua_elua_emulate_register_clear(L);
if(globalRegister) {
lua_pushstring(L,swig_SwigModule.name);
lua_pushvalue(L,-2);
lua_rawset(L,-4);
}
#endif
#endif
#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
/* invoke user-specific initialization */
SWIG_init_user(L);
/* end module */
/* Note: We do not clean up the stack here (Lua will do this for us). At this
point, we have the globals table and out module table on the stack. Returning
one value makes the module table the result of the require command. */
return 1;
#else
return 0;
#endif
}
#ifdef __cplusplus
}
#endif
const char* SWIG_LUACODE=
"";
void SWIG_init_user(lua_State* L)
{
/* exec Lua code if applicable */
SWIG_Lua_dostring(L,SWIG_LUACODE);
}
diff --git a/lib/clang/libllvm/Makefile b/lib/clang/libllvm/Makefile
index a2f1dcab8174..6a896c68c4a6 100644
--- a/lib/clang/libllvm/Makefile
+++ b/lib/clang/libllvm/Makefile
@@ -1,2029 +1,2029 @@
# $FreeBSD$
.include <src.opts.mk>
.include "../llvm.pre.mk"
LIB= llvm
INTERNALLIB=
CFLAGS+= -I${.OBJDIR}
.if ${MK_LLVM_TARGET_AARCH64} == "no" && ${MK_LLVM_TARGET_ARM} == "no" && \
${MK_LLVM_TARGET_BPF} == "no" && ${MK_LLVM_TARGET_MIPS} == "no" && \
${MK_LLVM_TARGET_POWERPC} == "no" && ${MK_LLVM_TARGET_RISCV} == "no" && \
${MK_LLVM_TARGET_X86} == "no"
.error Please enable at least one of: MK_LLVM_TARGET_AARCH64,\
MK_LLVM_TARGET_ARM, MK_LLVM_TARGET_BPF, MK_LLVM_TARGET_MIPS, \
MK_LLVM_TARGET_POWERPC, MK_LLVM_TARGET_RISCV, or MK_LLVM_TARGET_X86
.endif
.for arch in AArch64 ARM BPF Mips PowerPC RISCV X86
. if ${MK_LLVM_TARGET_${arch:tu}} != "no"
CFLAGS+= -I${LLVM_SRCS}/lib/Target/${arch}
. endif
.endfor
SRCDIR= llvm/lib
# Explanation of different SRCS variants below:
# SRCS_MIN: always required, even for bootstrap
# SRCS_MIW: required for world stage (after cross-tools)
# SRCS_EXT: required for MK_CLANG_EXTRAS
# SRCS_EXL: required for MK_CLANG_EXTRAS and MK_LLD
# SRCS_FUL: required for MK_CLANG_FULL
# SRCS_LLD: required for MK_LLD
# SRCS_XDB: required for MK_CLANG_EXTRAS and MK_LLDB
# SRCS_XDL: required for MK_CLANG_EXTRAS, MK_LLD and MK_LLDB
# SRCS_XDW: required for MK_CLANG_EXTRAS and MK_LLDB in world stage
SRCS_MIN+= Analysis/AliasAnalysis.cpp
SRCS_MIN+= Analysis/AliasAnalysisEvaluator.cpp
SRCS_MIN+= Analysis/AliasAnalysisSummary.cpp
SRCS_MIN+= Analysis/AliasSetTracker.cpp
SRCS_EXT+= Analysis/Analysis.cpp
SRCS_MIN+= Analysis/AssumeBundleQueries.cpp
SRCS_MIN+= Analysis/AssumptionCache.cpp
SRCS_MIN+= Analysis/BasicAliasAnalysis.cpp
SRCS_MIN+= Analysis/BlockFrequencyInfo.cpp
SRCS_MIN+= Analysis/BlockFrequencyInfoImpl.cpp
SRCS_MIN+= Analysis/BranchProbabilityInfo.cpp
SRCS_MIN+= Analysis/CFG.cpp
SRCS_MIN+= Analysis/CFGPrinter.cpp
SRCS_MIN+= Analysis/CFLAndersAliasAnalysis.cpp
SRCS_MIN+= Analysis/CFLSteensAliasAnalysis.cpp
SRCS_MIN+= Analysis/CGSCCPassManager.cpp
SRCS_MIN+= Analysis/CallGraph.cpp
SRCS_MIN+= Analysis/CallGraphSCCPass.cpp
SRCS_MIN+= Analysis/CallPrinter.cpp
SRCS_MIN+= Analysis/CaptureTracking.cpp
SRCS_MIN+= Analysis/CmpInstAnalysis.cpp
SRCS_MIN+= Analysis/CodeMetrics.cpp
SRCS_MIN+= Analysis/ConstantFolding.cpp
SRCS_MIN+= Analysis/ConstraintSystem.cpp
SRCS_MIN+= Analysis/CostModel.cpp
SRCS_MIN+= Analysis/CycleAnalysis.cpp
SRCS_MIN+= Analysis/DDG.cpp
SRCS_MIN+= Analysis/DDGPrinter.cpp
SRCS_MIN+= Analysis/Delinearization.cpp
SRCS_MIN+= Analysis/DemandedBits.cpp
SRCS_MIN+= Analysis/DependenceAnalysis.cpp
SRCS_MIN+= Analysis/DependenceGraphBuilder.cpp
SRCS_MIN+= Analysis/DivergenceAnalysis.cpp
SRCS_MIN+= Analysis/DomPrinter.cpp
SRCS_MIN+= Analysis/DomTreeUpdater.cpp
SRCS_MIN+= Analysis/DominanceFrontier.cpp
SRCS_MIN+= Analysis/EHPersonalities.cpp
SRCS_MIN+= Analysis/FunctionPropertiesAnalysis.cpp
SRCS_MIN+= Analysis/GlobalsModRef.cpp
SRCS_MIN+= Analysis/GuardUtils.cpp
SRCS_MIN+= Analysis/HeatUtils.cpp
SRCS_MIN+= Analysis/IRSimilarityIdentifier.cpp
SRCS_MIN+= Analysis/IVDescriptors.cpp
SRCS_MIN+= Analysis/IVUsers.cpp
SRCS_MIN+= Analysis/ImportedFunctionsInliningStatistics.cpp
SRCS_MIN+= Analysis/IndirectCallPromotionAnalysis.cpp
SRCS_MIN+= Analysis/InlineAdvisor.cpp
SRCS_MIN+= Analysis/InlineCost.cpp
SRCS_MIN+= Analysis/InlineSizeEstimatorAnalysis.cpp
SRCS_MIN+= Analysis/InstCount.cpp
SRCS_MIN+= Analysis/InstructionPrecedenceTracking.cpp
SRCS_MIN+= Analysis/InstructionSimplify.cpp
SRCS_MIN+= Analysis/Interval.cpp
SRCS_MIN+= Analysis/IntervalPartition.cpp
SRCS_MIN+= Analysis/LazyBlockFrequencyInfo.cpp
SRCS_MIN+= Analysis/LazyBranchProbabilityInfo.cpp
SRCS_MIN+= Analysis/LazyCallGraph.cpp
SRCS_MIN+= Analysis/LazyValueInfo.cpp
SRCS_MIN+= Analysis/LegacyDivergenceAnalysis.cpp
SRCS_MIN+= Analysis/Lint.cpp
SRCS_MIN+= Analysis/Loads.cpp
SRCS_MIN+= Analysis/LoopAccessAnalysis.cpp
SRCS_MIN+= Analysis/LoopAnalysisManager.cpp
SRCS_MIN+= Analysis/LoopCacheAnalysis.cpp
SRCS_MIN+= Analysis/LoopInfo.cpp
SRCS_MIN+= Analysis/LoopNestAnalysis.cpp
SRCS_MIN+= Analysis/LoopPass.cpp
SRCS_MIN+= Analysis/LoopUnrollAnalyzer.cpp
SRCS_MIN+= Analysis/MemDepPrinter.cpp
SRCS_MIN+= Analysis/MemDerefPrinter.cpp
SRCS_MIN+= Analysis/MemoryBuiltins.cpp
SRCS_MIN+= Analysis/MemoryDependenceAnalysis.cpp
SRCS_MIN+= Analysis/MemoryLocation.cpp
SRCS_MIN+= Analysis/MemorySSA.cpp
SRCS_MIN+= Analysis/MemorySSAUpdater.cpp
SRCS_MIN+= Analysis/ModuleDebugInfoPrinter.cpp
SRCS_MIN+= Analysis/ModuleSummaryAnalysis.cpp
SRCS_MIN+= Analysis/MustExecute.cpp
SRCS_MIN+= Analysis/ObjCARCAliasAnalysis.cpp
SRCS_MIN+= Analysis/ObjCARCAnalysisUtils.cpp
SRCS_MIN+= Analysis/ObjCARCInstKind.cpp
SRCS_MIN+= Analysis/OptimizationRemarkEmitter.cpp
SRCS_MIN+= Analysis/OverflowInstAnalysis.cpp
SRCS_MIN+= Analysis/PHITransAddr.cpp
SRCS_MIN+= Analysis/PhiValues.cpp
SRCS_MIN+= Analysis/PostDominators.cpp
SRCS_MIN+= Analysis/ProfileSummaryInfo.cpp
SRCS_MIN+= Analysis/PtrUseVisitor.cpp
SRCS_MIN+= Analysis/RegionInfo.cpp
SRCS_MIN+= Analysis/RegionPass.cpp
SRCS_MIN+= Analysis/RegionPrinter.cpp
SRCS_MIN+= Analysis/ReplayInlineAdvisor.cpp
SRCS_MIN+= Analysis/ScalarEvolution.cpp
SRCS_MIN+= Analysis/ScalarEvolution.cpp
SRCS_MIN+= Analysis/ScalarEvolutionAliasAnalysis.cpp
SRCS_MIN+= Analysis/ScalarEvolutionDivision.cpp
SRCS_MIN+= Analysis/ScalarEvolutionNormalization.cpp
SRCS_MIN+= Analysis/ScopedNoAliasAA.cpp
SRCS_MIN+= Analysis/StackLifetime.cpp
SRCS_MIN+= Analysis/StackSafetyAnalysis.cpp
SRCS_MIN+= Analysis/SyncDependenceAnalysis.cpp
SRCS_MIN+= Analysis/SyntheticCountsUtils.cpp
SRCS_MIN+= Analysis/TargetLibraryInfo.cpp
SRCS_MIN+= Analysis/TargetTransformInfo.cpp
SRCS_MIN+= Analysis/TypeBasedAliasAnalysis.cpp
SRCS_MIN+= Analysis/TypeMetadataUtils.cpp
SRCS_MIN+= Analysis/VFABIDemangling.cpp
SRCS_MIN+= Analysis/ValueLattice.cpp
SRCS_MIN+= Analysis/ValueLatticeUtils.cpp
SRCS_MIN+= Analysis/ValueTracking.cpp
SRCS_MIN+= Analysis/VectorUtils.cpp
SRCS_MIN+= AsmParser/LLLexer.cpp
SRCS_MIN+= AsmParser/LLParser.cpp
SRCS_MIN+= AsmParser/Parser.cpp
SRCS_MIN+= BinaryFormat/AMDGPUMetadataVerifier.cpp
SRCS_MIN+= BinaryFormat/Dwarf.cpp
SRCS_MIN+= BinaryFormat/Magic.cpp
SRCS_MIN+= BinaryFormat/MachO.cpp
SRCS_MIN+= BinaryFormat/MsgPackDocument.cpp
SRCS_MIN+= BinaryFormat/MsgPackDocumentYAML.cpp
SRCS_MIN+= BinaryFormat/MsgPackReader.cpp
SRCS_MIN+= BinaryFormat/MsgPackWriter.cpp
SRCS_MIN+= BinaryFormat/Wasm.cpp
SRCS_MIN+= BinaryFormat/XCOFF.cpp
SRCS_MIN+= Bitcode/Reader/BitReader.cpp
SRCS_EXT+= Bitcode/Reader/BitcodeAnalyzer.cpp
SRCS_MIN+= Bitcode/Reader/BitcodeReader.cpp
SRCS_MIN+= Bitcode/Reader/MetadataLoader.cpp
SRCS_MIN+= Bitcode/Reader/ValueList.cpp
SRCS_MIN+= Bitcode/Writer/BitcodeWriter.cpp
SRCS_MIN+= Bitcode/Writer/BitcodeWriterPass.cpp
SRCS_MIN+= Bitcode/Writer/ValueEnumerator.cpp
SRCS_MIN+= Bitstream/Reader/BitstreamReader.cpp
SRCS_MIN+= CodeGen/AggressiveAntiDepBreaker.cpp
SRCS_MIN+= CodeGen/AllocationOrder.cpp
SRCS_MIN+= CodeGen/Analysis.cpp
SRCS_MIN+= CodeGen/AsmPrinter/AIXException.cpp
SRCS_MIN+= CodeGen/AsmPrinter/ARMException.cpp
SRCS_MIN+= CodeGen/AsmPrinter/AccelTable.cpp
SRCS_MIN+= CodeGen/AsmPrinter/AddressPool.cpp
SRCS_MIN+= CodeGen/AsmPrinter/AsmPrinter.cpp
SRCS_MIN+= CodeGen/AsmPrinter/AsmPrinterDwarf.cpp
SRCS_MIN+= CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp
SRCS_MIN+= CodeGen/AsmPrinter/CodeViewDebug.cpp
SRCS_MIN+= CodeGen/AsmPrinter/DIE.cpp
SRCS_MIN+= CodeGen/AsmPrinter/DIEHash.cpp
SRCS_MIN+= CodeGen/AsmPrinter/DbgEntityHistoryCalculator.cpp
SRCS_MIN+= CodeGen/AsmPrinter/DebugHandlerBase.cpp
SRCS_MIN+= CodeGen/AsmPrinter/DebugLocStream.cpp
SRCS_MIN+= CodeGen/AsmPrinter/DwarfCFIException.cpp
SRCS_MIN+= CodeGen/AsmPrinter/DwarfCompileUnit.cpp
SRCS_MIN+= CodeGen/AsmPrinter/DwarfDebug.cpp
SRCS_MIN+= CodeGen/AsmPrinter/DwarfExpression.cpp
SRCS_MIN+= CodeGen/AsmPrinter/DwarfFile.cpp
SRCS_MIN+= CodeGen/AsmPrinter/DwarfStringPool.cpp
SRCS_MIN+= CodeGen/AsmPrinter/DwarfUnit.cpp
SRCS_MIN+= CodeGen/AsmPrinter/EHStreamer.cpp
SRCS_EXT+= CodeGen/AsmPrinter/ErlangGCPrinter.cpp
SRCS_MIN+= CodeGen/AsmPrinter/OcamlGCPrinter.cpp
SRCS_MIN+= CodeGen/AsmPrinter/PseudoProbePrinter.cpp
SRCS_MIN+= CodeGen/AsmPrinter/WasmException.cpp
SRCS_MIN+= CodeGen/AsmPrinter/WinCFGuard.cpp
SRCS_MIN+= CodeGen/AsmPrinter/WinException.cpp
SRCS_MIN+= CodeGen/AtomicExpandPass.cpp
SRCS_MIN+= CodeGen/BasicBlockSections.cpp
SRCS_MIN+= CodeGen/BasicTargetTransformInfo.cpp
SRCS_MIN+= CodeGen/BranchFolding.cpp
SRCS_MIN+= CodeGen/BranchRelaxation.cpp
SRCS_MIN+= CodeGen/BreakFalseDeps.cpp
SRCS_MIN+= CodeGen/CFGuardLongjmp.cpp
SRCS_MIN+= CodeGen/CFIInstrInserter.cpp
SRCS_MIN+= CodeGen/CalcSpillWeights.cpp
SRCS_MIN+= CodeGen/CallingConvLower.cpp
SRCS_MIN+= CodeGen/CodeGen.cpp
SRCS_MIN+= CodeGen/CodeGenCommonISel.cpp
SRCS_MIN+= CodeGen/CodeGenPrepare.cpp
SRCS_EXL+= CodeGen/CommandFlags.cpp
SRCS_MIN+= CodeGen/CriticalAntiDepBreaker.cpp
SRCS_MIN+= CodeGen/DFAPacketizer.cpp
SRCS_MIN+= CodeGen/DeadMachineInstructionElim.cpp
SRCS_MIN+= CodeGen/DetectDeadLanes.cpp
SRCS_MIN+= CodeGen/DwarfEHPrepare.cpp
SRCS_MIN+= CodeGen/EHContGuardCatchret.cpp
SRCS_MIN+= CodeGen/EarlyIfConversion.cpp
SRCS_MIN+= CodeGen/EdgeBundles.cpp
SRCS_MIN+= CodeGen/ExecutionDomainFix.cpp
SRCS_MIN+= CodeGen/ExpandMemCmp.cpp
SRCS_MIN+= CodeGen/ExpandPostRAPseudos.cpp
SRCS_MIN+= CodeGen/ExpandReductions.cpp
SRCS_MIN+= CodeGen/ExpandVectorPredication.cpp
SRCS_MIN+= CodeGen/FEntryInserter.cpp
SRCS_MIN+= CodeGen/FaultMaps.cpp
SRCS_MIN+= CodeGen/FinalizeISel.cpp
SRCS_MIN+= CodeGen/FixupStatepointCallerSaved.cpp
SRCS_MIN+= CodeGen/FuncletLayout.cpp
SRCS_MIN+= CodeGen/GCMetadata.cpp
SRCS_MIN+= CodeGen/GCMetadataPrinter.cpp
SRCS_MIN+= CodeGen/GCRootLowering.cpp
SRCS_MIN+= CodeGen/GlobalISel/CSEInfo.cpp
SRCS_MIN+= CodeGen/GlobalISel/CSEMIRBuilder.cpp
SRCS_MIN+= CodeGen/GlobalISel/Combiner.cpp
SRCS_MIN+= CodeGen/GlobalISel/CombinerHelper.cpp
SRCS_MIN+= CodeGen/GlobalISel/CallLowering.cpp
SRCS_MIN+= CodeGen/GlobalISel/GISelChangeObserver.cpp
SRCS_MIN+= CodeGen/GlobalISel/GISelKnownBits.cpp
SRCS_MIN+= CodeGen/GlobalISel/GlobalISel.cpp
SRCS_MIN+= CodeGen/GlobalISel/IRTranslator.cpp
SRCS_MIN+= CodeGen/GlobalISel/InlineAsmLowering.cpp
SRCS_MIN+= CodeGen/GlobalISel/InstructionSelect.cpp
SRCS_MIN+= CodeGen/GlobalISel/InstructionSelector.cpp
SRCS_MIN+= CodeGen/GlobalISel/LegacyLegalizerInfo.cpp
SRCS_MIN+= CodeGen/GlobalISel/LegalityPredicates.cpp
SRCS_MIN+= CodeGen/GlobalISel/LegalizeMutations.cpp
SRCS_MIN+= CodeGen/GlobalISel/Legalizer.cpp
SRCS_MIN+= CodeGen/GlobalISel/LegalizerHelper.cpp
SRCS_MIN+= CodeGen/GlobalISel/LegalizerInfo.cpp
SRCS_MIN+= CodeGen/GlobalISel/LoadStoreOpt.cpp
SRCS_MIN+= CodeGen/GlobalISel/Localizer.cpp
SRCS_MIN+= CodeGen/GlobalISel/LostDebugLocObserver.cpp
SRCS_MIN+= CodeGen/GlobalISel/MachineIRBuilder.cpp
SRCS_MIN+= CodeGen/GlobalISel/RegBankSelect.cpp
SRCS_MIN+= CodeGen/GlobalISel/RegisterBank.cpp
SRCS_MIN+= CodeGen/GlobalISel/RegisterBankInfo.cpp
SRCS_MIN+= CodeGen/GlobalISel/Utils.cpp
SRCS_MIN+= CodeGen/GlobalMerge.cpp
SRCS_MIN+= CodeGen/HardwareLoops.cpp
SRCS_MIN+= CodeGen/IfConversion.cpp
SRCS_MIN+= CodeGen/ImplicitNullChecks.cpp
SRCS_MIN+= CodeGen/IndirectBrExpandPass.cpp
SRCS_MIN+= CodeGen/InlineSpiller.cpp
SRCS_MIN+= CodeGen/InterferenceCache.cpp
SRCS_MIN+= CodeGen/InterleavedAccessPass.cpp
SRCS_MIN+= CodeGen/InterleavedLoadCombinePass.cpp
SRCS_MIN+= CodeGen/IntrinsicLowering.cpp
SRCS_MIN+= CodeGen/LLVMTargetMachine.cpp
SRCS_MIN+= CodeGen/LatencyPriorityQueue.cpp
SRCS_MIN+= CodeGen/LazyMachineBlockFrequencyInfo.cpp
SRCS_MIN+= CodeGen/LexicalScopes.cpp
SRCS_MIN+= CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp
SRCS_MIN+= CodeGen/LiveDebugValues/LiveDebugValues.cpp
SRCS_MIN+= CodeGen/LiveDebugValues/VarLocBasedImpl.cpp
SRCS_MIN+= CodeGen/LiveDebugVariables.cpp
SRCS_MIN+= CodeGen/LiveInterval.cpp
SRCS_MIN+= CodeGen/LiveIntervalCalc.cpp
SRCS_MIN+= CodeGen/LiveIntervalUnion.cpp
SRCS_MIN+= CodeGen/LiveIntervals.cpp
SRCS_MIN+= CodeGen/LivePhysRegs.cpp
SRCS_MIN+= CodeGen/LiveRangeCalc.cpp
SRCS_MIN+= CodeGen/LiveRangeEdit.cpp
SRCS_MIN+= CodeGen/LiveRangeShrink.cpp
SRCS_MIN+= CodeGen/LiveRegMatrix.cpp
SRCS_MIN+= CodeGen/LiveRegUnits.cpp
SRCS_MIN+= CodeGen/LiveStacks.cpp
SRCS_MIN+= CodeGen/LiveVariables.cpp
SRCS_MIN+= CodeGen/LocalStackSlotAllocation.cpp
SRCS_MIN+= CodeGen/LoopTraversal.cpp
SRCS_MIN+= CodeGen/LowLevelType.cpp
SRCS_MIN+= CodeGen/LowerEmuTLS.cpp
SRCS_MIN+= CodeGen/MBFIWrapper.cpp
SRCS_MIN+= CodeGen/MIRCanonicalizerPass.cpp
SRCS_MIN+= CodeGen/MIRFSDiscriminator.cpp
SRCS_MIN+= CodeGen/MIRNamerPass.cpp
SRCS_EXT+= CodeGen/MIRParser/MILexer.cpp
SRCS_EXT+= CodeGen/MIRParser/MIParser.cpp
SRCS_EXT+= CodeGen/MIRParser/MIRParser.cpp
SRCS_MIN+= CodeGen/MIRPrinter.cpp
SRCS_MIN+= CodeGen/MIRPrintingPass.cpp
SRCS_MIN+= CodeGen/MIRSampleProfile.cpp
SRCS_MIN+= CodeGen/MIRVRegNamerUtils.cpp
SRCS_MIN+= CodeGen/MLRegallocEvictAdvisor.cpp
SRCS_MIN+= CodeGen/MachineBasicBlock.cpp
SRCS_MIN+= CodeGen/MachineBlockFrequencyInfo.cpp
SRCS_MIN+= CodeGen/MachineBlockPlacement.cpp
SRCS_MIN+= CodeGen/MachineBranchProbabilityInfo.cpp
SRCS_MIN+= CodeGen/MachineCSE.cpp
SRCS_MIN+= CodeGen/MachineCheckDebugify.cpp
SRCS_MIN+= CodeGen/MachineCombiner.cpp
SRCS_MIN+= CodeGen/MachineCopyPropagation.cpp
SRCS_MIN+= CodeGen/MachineCycleAnalysis.cpp
SRCS_MIN+= CodeGen/MachineDebugify.cpp
SRCS_MIN+= CodeGen/MachineDominanceFrontier.cpp
SRCS_MIN+= CodeGen/MachineDominators.cpp
SRCS_MIN+= CodeGen/MachineFrameInfo.cpp
SRCS_MIN+= CodeGen/MachineFunction.cpp
SRCS_MIN+= CodeGen/MachineFunctionPass.cpp
SRCS_MIN+= CodeGen/MachineFunctionPrinterPass.cpp
SRCS_MIN+= CodeGen/MachineFunctionSplitter.cpp
SRCS_MIN+= CodeGen/MachineInstr.cpp
SRCS_MIN+= CodeGen/MachineInstrBundle.cpp
SRCS_MIN+= CodeGen/MachineLICM.cpp
SRCS_MIN+= CodeGen/MachineLoopInfo.cpp
SRCS_MIN+= CodeGen/MachineLoopUtils.cpp
SRCS_MIN+= CodeGen/MachineModuleInfo.cpp
SRCS_MIN+= CodeGen/MachineModuleInfoImpls.cpp
SRCS_MIN+= CodeGen/MachineModuleSlotTracker.cpp
SRCS_MIN+= CodeGen/MachineOperand.cpp
SRCS_MIN+= CodeGen/MachineOptimizationRemarkEmitter.cpp
SRCS_MIN+= CodeGen/MachineOutliner.cpp
SRCS_MIN+= CodeGen/MachinePipeliner.cpp
SRCS_MIN+= CodeGen/MachinePostDominators.cpp
SRCS_MIN+= CodeGen/MachineRegionInfo.cpp
SRCS_MIN+= CodeGen/MachineRegisterInfo.cpp
SRCS_MIN+= CodeGen/MachineSSAContext.cpp
SRCS_MIN+= CodeGen/MachineSSAUpdater.cpp
SRCS_MIN+= CodeGen/MachineScheduler.cpp
SRCS_MIN+= CodeGen/MachineSink.cpp
SRCS_MIN+= CodeGen/MachineSizeOpts.cpp
SRCS_MIN+= CodeGen/MachineStableHash.cpp
SRCS_MIN+= CodeGen/MachineStripDebug.cpp
SRCS_MIN+= CodeGen/MachineTraceMetrics.cpp
SRCS_MIN+= CodeGen/MachineVerifier.cpp
SRCS_MIN+= CodeGen/MacroFusion.cpp
SRCS_MIN+= CodeGen/ModuloSchedule.cpp
SRCS_MIN+= CodeGen/MultiHazardRecognizer.cpp
SRCS_MIN+= CodeGen/OptimizePHIs.cpp
SRCS_MIN+= CodeGen/PHIElimination.cpp
SRCS_MIN+= CodeGen/PHIEliminationUtils.cpp
SRCS_MIN+= CodeGen/ParallelCG.cpp
SRCS_MIN+= CodeGen/PatchableFunction.cpp
SRCS_MIN+= CodeGen/PeepholeOptimizer.cpp
SRCS_MIN+= CodeGen/PostRAHazardRecognizer.cpp
SRCS_MIN+= CodeGen/PostRASchedulerList.cpp
SRCS_MIN+= CodeGen/PreISelIntrinsicLowering.cpp
SRCS_MIN+= CodeGen/ProcessImplicitDefs.cpp
SRCS_MIN+= CodeGen/PrologEpilogInserter.cpp
SRCS_MIN+= CodeGen/PseudoProbeInserter.cpp
SRCS_MIN+= CodeGen/PseudoSourceValue.cpp
SRCS_MIN+= CodeGen/ReachingDefAnalysis.cpp
SRCS_MIN+= CodeGen/ReplaceWithVeclib.cpp
SRCS_MIN+= CodeGen/RDFGraph.cpp
SRCS_MIN+= CodeGen/RDFLiveness.cpp
SRCS_MIN+= CodeGen/RDFRegisters.cpp
SRCS_MIN+= CodeGen/RegAllocBase.cpp
SRCS_MIN+= CodeGen/RegAllocBasic.cpp
SRCS_MIN+= CodeGen/RegAllocEvictionAdvisor.cpp
SRCS_MIN+= CodeGen/RegAllocFast.cpp
SRCS_MIN+= CodeGen/RegAllocGreedy.cpp
SRCS_MIN+= CodeGen/RegAllocPBQP.cpp
SRCS_MIN+= CodeGen/RegUsageInfoCollector.cpp
SRCS_MIN+= CodeGen/RegUsageInfoPropagate.cpp
SRCS_MIN+= CodeGen/RegisterClassInfo.cpp
SRCS_MIN+= CodeGen/RegisterCoalescer.cpp
SRCS_MIN+= CodeGen/RegisterPressure.cpp
SRCS_MIN+= CodeGen/RegisterScavenging.cpp
SRCS_MIN+= CodeGen/RegisterUsageInfo.cpp
SRCS_MIN+= CodeGen/RemoveRedundantDebugValues.cpp
SRCS_MIN+= CodeGen/RenameIndependentSubregs.cpp
SRCS_MIN+= CodeGen/ResetMachineFunctionPass.cpp
SRCS_MIN+= CodeGen/SafeStack.cpp
SRCS_MIN+= CodeGen/SafeStackLayout.cpp
SRCS_MIN+= CodeGen/ScheduleDAG.cpp
SRCS_MIN+= CodeGen/ScheduleDAGInstrs.cpp
SRCS_MIN+= CodeGen/ScheduleDAGPrinter.cpp
SRCS_MIN+= CodeGen/ScoreboardHazardRecognizer.cpp
SRCS_MIN+= CodeGen/SelectionDAG/DAGCombiner.cpp
SRCS_MIN+= CodeGen/SelectionDAG/FastISel.cpp
SRCS_MIN+= CodeGen/SelectionDAG/FunctionLoweringInfo.cpp
SRCS_MIN+= CodeGen/SelectionDAG/InstrEmitter.cpp
SRCS_MIN+= CodeGen/SelectionDAG/LegalizeDAG.cpp
SRCS_MIN+= CodeGen/SelectionDAG/LegalizeFloatTypes.cpp
SRCS_MIN+= CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp
SRCS_MIN+= CodeGen/SelectionDAG/LegalizeTypes.cpp
SRCS_MIN+= CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp
SRCS_MIN+= CodeGen/SelectionDAG/LegalizeVectorOps.cpp
SRCS_MIN+= CodeGen/SelectionDAG/LegalizeVectorTypes.cpp
SRCS_MIN+= CodeGen/SelectionDAG/ResourcePriorityQueue.cpp
SRCS_MIN+= CodeGen/SelectionDAG/ScheduleDAGFast.cpp
SRCS_MIN+= CodeGen/SelectionDAG/ScheduleDAGRRList.cpp
SRCS_MIN+= CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp
SRCS_MIN+= CodeGen/SelectionDAG/ScheduleDAGVLIW.cpp
SRCS_MIN+= CodeGen/SelectionDAG/SelectionDAG.cpp
SRCS_MIN+= CodeGen/SelectionDAG/SelectionDAGAddressAnalysis.cpp
SRCS_MIN+= CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
SRCS_MIN+= CodeGen/SelectionDAG/SelectionDAGDumper.cpp
SRCS_MIN+= CodeGen/SelectionDAG/SelectionDAGISel.cpp
SRCS_MIN+= CodeGen/SelectionDAG/SelectionDAGPrinter.cpp
SRCS_MIN+= CodeGen/SelectionDAG/SelectionDAGTargetInfo.cpp
SRCS_MIN+= CodeGen/SelectionDAG/StatepointLowering.cpp
SRCS_MIN+= CodeGen/SelectionDAG/TargetLowering.cpp
SRCS_MIN+= CodeGen/ShadowStackGCLowering.cpp
SRCS_MIN+= CodeGen/ShrinkWrap.cpp
SRCS_MIN+= CodeGen/SjLjEHPrepare.cpp
SRCS_MIN+= CodeGen/SlotIndexes.cpp
SRCS_MIN+= CodeGen/SpillPlacement.cpp
SRCS_MIN+= CodeGen/SplitKit.cpp
SRCS_MIN+= CodeGen/StackColoring.cpp
SRCS_MIN+= CodeGen/StackMapLivenessAnalysis.cpp
SRCS_MIN+= CodeGen/StackMaps.cpp
SRCS_MIN+= CodeGen/StackProtector.cpp
SRCS_MIN+= CodeGen/StackSlotColoring.cpp
SRCS_MIN+= CodeGen/SwiftErrorValueTracking.cpp
SRCS_MIN+= CodeGen/SwitchLoweringUtils.cpp
SRCS_MIN+= CodeGen/TailDuplication.cpp
SRCS_MIN+= CodeGen/TailDuplicator.cpp
SRCS_MIN+= CodeGen/TargetFrameLoweringImpl.cpp
SRCS_MIN+= CodeGen/TargetInstrInfo.cpp
SRCS_MIN+= CodeGen/TargetLoweringBase.cpp
SRCS_MIN+= CodeGen/TargetLoweringObjectFileImpl.cpp
SRCS_MIN+= CodeGen/TargetOptionsImpl.cpp
SRCS_MIN+= CodeGen/TargetPassConfig.cpp
SRCS_MIN+= CodeGen/TargetRegisterInfo.cpp
SRCS_MIN+= CodeGen/TargetSchedule.cpp
SRCS_MIN+= CodeGen/TargetSubtargetInfo.cpp
SRCS_MIN+= CodeGen/TwoAddressInstructionPass.cpp
SRCS_MIN+= CodeGen/TypePromotion.cpp
SRCS_MIN+= CodeGen/UnreachableBlockElim.cpp
SRCS_MIN+= CodeGen/ValueTypes.cpp
SRCS_MIN+= CodeGen/VirtRegMap.cpp
SRCS_MIN+= CodeGen/WasmEHPrepare.cpp
SRCS_MIN+= CodeGen/WinEHPrepare.cpp
SRCS_MIN+= CodeGen/XRayInstrumentation.cpp
SRCS_EXT+= DWP/DWP.cpp
SRCS_EXT+= DWP/DWPError.cpp
SRCS_EXT+= DebugInfo/CodeView/AppendingTypeTableBuilder.cpp
SRCS_MIN+= DebugInfo/CodeView/CVSymbolVisitor.cpp
SRCS_MIN+= DebugInfo/CodeView/CVTypeVisitor.cpp
SRCS_MIN+= DebugInfo/CodeView/CodeViewError.cpp
SRCS_MIN+= DebugInfo/CodeView/CodeViewRecordIO.cpp
SRCS_MIN+= DebugInfo/CodeView/ContinuationRecordBuilder.cpp
SRCS_MIN+= DebugInfo/CodeView/DebugChecksumsSubsection.cpp
SRCS_EXT+= DebugInfo/CodeView/DebugCrossExSubsection.cpp
SRCS_EXT+= DebugInfo/CodeView/DebugCrossImpSubsection.cpp
SRCS_MIN+= DebugInfo/CodeView/DebugFrameDataSubsection.cpp
SRCS_MIN+= DebugInfo/CodeView/DebugInlineeLinesSubsection.cpp
SRCS_MIN+= DebugInfo/CodeView/DebugLinesSubsection.cpp
SRCS_MIN+= DebugInfo/CodeView/DebugStringTableSubsection.cpp
SRCS_MIW+= DebugInfo/CodeView/DebugSubsection.cpp
SRCS_EXT+= DebugInfo/CodeView/DebugSubsectionRecord.cpp
SRCS_EXT+= DebugInfo/CodeView/DebugSubsectionVisitor.cpp
SRCS_EXT+= DebugInfo/CodeView/DebugSymbolRVASubsection.cpp
SRCS_EXT+= DebugInfo/CodeView/DebugSymbolsSubsection.cpp
SRCS_MIN+= DebugInfo/CodeView/EnumTables.cpp
SRCS_MIN+= DebugInfo/CodeView/Formatters.cpp
SRCS_MIN+= DebugInfo/CodeView/GlobalTypeTableBuilder.cpp
SRCS_MIN+= DebugInfo/CodeView/LazyRandomTypeCollection.cpp
SRCS_MIN+= DebugInfo/CodeView/Line.cpp
SRCS_MIN+= DebugInfo/CodeView/MergingTypeTableBuilder.cpp
SRCS_MIN+= DebugInfo/CodeView/RecordName.cpp
SRCS_MIN+= DebugInfo/CodeView/RecordSerialization.cpp
SRCS_MIN+= DebugInfo/CodeView/SimpleTypeSerializer.cpp
SRCS_EXT+= DebugInfo/CodeView/StringsAndChecksums.cpp
SRCS_MIN+= DebugInfo/CodeView/SymbolDumper.cpp
SRCS_MIN+= DebugInfo/CodeView/SymbolRecordMapping.cpp
SRCS_EXT+= DebugInfo/CodeView/SymbolSerializer.cpp
SRCS_MIN+= DebugInfo/CodeView/TypeDumpVisitor.cpp
SRCS_MIN+= DebugInfo/CodeView/TypeHashing.cpp
SRCS_MIN+= DebugInfo/CodeView/TypeIndex.cpp
SRCS_MIN+= DebugInfo/CodeView/TypeIndexDiscovery.cpp
SRCS_EXT+= DebugInfo/CodeView/TypeRecordHelpers.cpp
SRCS_MIN+= DebugInfo/CodeView/TypeRecordMapping.cpp
SRCS_MIN+= DebugInfo/CodeView/TypeStreamMerger.cpp
SRCS_MIN+= DebugInfo/CodeView/TypeTableCollection.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFAbbreviationDeclaration.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFAcceleratorTable.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFAddressRange.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFCompileUnit.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFContext.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFDataExtractor.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFDebugAbbrev.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFDebugAddr.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFDebugArangeSet.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFDebugAranges.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFDebugFrame.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFDebugInfoEntry.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFDebugLine.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFDebugLoc.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFDebugMacro.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFDebugPubTable.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFDebugRangeList.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFDebugRnglists.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFDie.cpp
SRCS_MIN+= DebugInfo/DWARF/DWARFExpression.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFFormValue.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFGdbIndex.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFListTable.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFTypeUnit.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFUnit.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFUnitIndex.cpp
SRCS_MIW+= DebugInfo/DWARF/DWARFVerifier.cpp
SRCS_MIN+= DebugInfo/MSF/MSFBuilder.cpp
SRCS_MIN+= DebugInfo/MSF/MSFCommon.cpp
SRCS_EXT+= DebugInfo/MSF/MSFError.cpp
SRCS_MIN+= DebugInfo/MSF/MappedBlockStream.cpp
SRCS_EXT+= DebugInfo/PDB/GenericError.cpp
SRCS_EXT+= DebugInfo/PDB/IPDBSourceFile.cpp
SRCS_EXT+= DebugInfo/PDB/Native/DbiModuleDescriptor.cpp
SRCS_EXT+= DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.cpp
SRCS_EXT+= DebugInfo/PDB/Native/DbiModuleList.cpp
SRCS_EXT+= DebugInfo/PDB/Native/DbiStream.cpp
SRCS_EXT+= DebugInfo/PDB/Native/DbiStreamBuilder.cpp
SRCS_EXT+= DebugInfo/PDB/Native/EnumTables.cpp
SRCS_EXT+= DebugInfo/PDB/Native/GSIStreamBuilder.cpp
SRCS_EXT+= DebugInfo/PDB/Native/GlobalsStream.cpp
SRCS_EXT+= DebugInfo/PDB/Native/Hash.cpp
SRCS_EXT+= DebugInfo/PDB/Native/HashTable.cpp
SRCS_EXT+= DebugInfo/PDB/Native/InfoStream.cpp
SRCS_EXT+= DebugInfo/PDB/Native/InfoStreamBuilder.cpp
SRCS_EXT+= DebugInfo/PDB/Native/InjectedSourceStream.cpp
SRCS_EXT+= DebugInfo/PDB/Native/ModuleDebugStream.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NamedStreamMap.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeCompilandSymbol.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeEnumGlobals.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeEnumInjectedSources.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeEnumLineNumbers.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeEnumModules.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeEnumSymbols.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeEnumTypes.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeExeSymbol.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeFunctionSymbol.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeInlineSiteSymbol.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeLineNumber.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativePublicSymbol.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeRawSymbol.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeSession.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeSourceFile.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeSymbolEnumerator.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeTypeArray.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeTypeBuiltin.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeTypeEnum.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeTypeFunctionSig.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeTypePointer.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeTypeTypedef.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeTypeUDT.cpp
SRCS_EXT+= DebugInfo/PDB/Native/NativeTypeVTShape.cpp
SRCS_EXT+= DebugInfo/PDB/Native/PDBFile.cpp
SRCS_EXT+= DebugInfo/PDB/Native/PDBFileBuilder.cpp
SRCS_EXT+= DebugInfo/PDB/Native/PDBStringTable.cpp
SRCS_EXT+= DebugInfo/PDB/Native/PDBStringTableBuilder.cpp
SRCS_EXT+= DebugInfo/PDB/Native/PublicsStream.cpp
SRCS_EXT+= DebugInfo/PDB/Native/RawError.cpp
SRCS_EXT+= DebugInfo/PDB/Native/SymbolCache.cpp
SRCS_EXT+= DebugInfo/PDB/Native/SymbolStream.cpp
SRCS_EXT+= DebugInfo/PDB/Native/TpiHashing.cpp
SRCS_EXT+= DebugInfo/PDB/Native/TpiStream.cpp
SRCS_EXT+= DebugInfo/PDB/Native/TpiStreamBuilder.cpp
SRCS_EXT+= DebugInfo/PDB/PDB.cpp
SRCS_EXT+= DebugInfo/PDB/PDBContext.cpp
SRCS_EXT+= DebugInfo/PDB/PDBExtras.cpp
SRCS_EXT+= DebugInfo/PDB/PDBInterfaceAnchors.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymDumper.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbol.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolAnnotation.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolBlock.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolCompiland.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolCompilandDetails.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolCompilandEnv.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolCustom.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolData.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolExe.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolFunc.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolFuncDebugEnd.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolFuncDebugStart.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolLabel.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolPublicSymbol.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolThunk.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolTypeArray.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolTypeBaseClass.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolTypeBuiltin.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolTypeCustom.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolTypeDimension.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolTypeEnum.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolTypeFriend.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolTypeFunctionArg.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolTypeFunctionSig.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolTypeManaged.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolTypePointer.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolTypeTypedef.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolTypeUDT.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolTypeVTable.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolTypeVTableShape.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolUnknown.cpp
SRCS_EXT+= DebugInfo/PDB/PDBSymbolUsingNamespace.cpp
SRCS_EXT+= DebugInfo/PDB/UDTLayout.cpp
SRCS_MIW+= DebugInfo/Symbolize/DIPrinter.cpp
SRCS_MIW+= DebugInfo/Symbolize/SymbolizableObjectFile.cpp
SRCS_MIW+= DebugInfo/Symbolize/Symbolize.cpp
SRCS_MIW+= Debuginfod/Debuginfod.cpp
SRCS_MIW+= Debuginfod/HTTPClient.cpp
SRCS_MIN+= Demangle/DLangDemangle.cpp
SRCS_MIN+= Demangle/Demangle.cpp
SRCS_MIN+= Demangle/ItaniumDemangle.cpp
SRCS_MIN+= Demangle/MicrosoftDemangle.cpp
SRCS_MIN+= Demangle/MicrosoftDemangleNodes.cpp
SRCS_MIN+= Demangle/RustDemangle.cpp
SRCS_XDB+= ExecutionEngine/ExecutionEngine.cpp
SRCS_XDB+= ExecutionEngine/ExecutionEngineBindings.cpp
SRCS_XDB+= ExecutionEngine/GDBRegistrationListener.cpp
SRCS_XDB+= ExecutionEngine/Interpreter/Execution.cpp
SRCS_XDB+= ExecutionEngine/Interpreter/ExternalFunctions.cpp
SRCS_XDB+= ExecutionEngine/Interpreter/Interpreter.cpp
SRCS_EXT+= ExecutionEngine/JITLink/EHFrameSupport.cpp
SRCS_EXT+= ExecutionEngine/JITLink/ELF.cpp
SRCS_EXT+= ExecutionEngine/JITLink/ELF_aarch64.cpp
SRCS_EXT+= ExecutionEngine/JITLink/ELF_riscv.cpp
SRCS_EXT+= ExecutionEngine/JITLink/ELF_x86_64.cpp
SRCS_EXT+= ExecutionEngine/JITLink/ELFLinkGraphBuilder.cpp
SRCS_EXT+= ExecutionEngine/JITLink/JITLink.cpp
SRCS_EXT+= ExecutionEngine/JITLink/JITLinkGeneric.cpp
SRCS_EXT+= ExecutionEngine/JITLink/JITLinkMemoryManager.cpp
SRCS_EXT+= ExecutionEngine/JITLink/MachO.cpp
SRCS_EXT+= ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp
SRCS_EXT+= ExecutionEngine/JITLink/MachO_arm64.cpp
SRCS_EXT+= ExecutionEngine/JITLink/MachO_x86_64.cpp
SRCS_EXT+= ExecutionEngine/JITLink/MemoryFlags.cpp
SRCS_EXT+= ExecutionEngine/JITLink/aarch64.cpp
SRCS_EXT+= ExecutionEngine/JITLink/riscv.cpp
SRCS_EXT+= ExecutionEngine/JITLink/x86_64.cpp
SRCS_XDB+= ExecutionEngine/MCJIT/MCJIT.cpp
SRCS_EXT+= ExecutionEngine/Orc/CompileOnDemandLayer.cpp
SRCS_EXT+= ExecutionEngine/Orc/CompileUtils.cpp
SRCS_EXT+= ExecutionEngine/Orc/Core.cpp
SRCS_EXT+= ExecutionEngine/Orc/DebugObjectManagerPlugin.cpp
SRCS_EXT+= ExecutionEngine/Orc/DebugUtils.cpp
SRCS_EXT+= ExecutionEngine/Orc/ELFNixPlatform.cpp
SRCS_EXT+= ExecutionEngine/Orc/EPCDebugObjectRegistrar.cpp
SRCS_EXT+= ExecutionEngine/Orc/EPCEHFrameRegistrar.cpp
SRCS_EXT+= ExecutionEngine/Orc/EPCGenericDylibManager.cpp
SRCS_EXT+= ExecutionEngine/Orc/EPCGenericJITLinkMemoryManager.cpp
SRCS_EXT+= ExecutionEngine/Orc/EPCGenericRTDyldMemoryManager.cpp
SRCS_EXT+= ExecutionEngine/Orc/ExecutionUtils.cpp
SRCS_EXT+= ExecutionEngine/Orc/ExecutorProcessControl.cpp
SRCS_EXT+= ExecutionEngine/Orc/IRCompileLayer.cpp
SRCS_EXT+= ExecutionEngine/Orc/IRTransformLayer.cpp
SRCS_EXT+= ExecutionEngine/Orc/IndirectionUtils.cpp
SRCS_EXT+= ExecutionEngine/Orc/JITTargetMachineBuilder.cpp
SRCS_EXT+= ExecutionEngine/Orc/LLJIT.cpp
SRCS_EXT+= ExecutionEngine/Orc/Layer.cpp
SRCS_EXT+= ExecutionEngine/Orc/LazyReexports.cpp
SRCS_EXT+= ExecutionEngine/Orc/MachOPlatform.cpp
SRCS_EXT+= ExecutionEngine/Orc/Mangling.cpp
SRCS_EXT+= ExecutionEngine/Orc/ObjectFileInterface.cpp
SRCS_EXT+= ExecutionEngine/Orc/ObjectLinkingLayer.cpp
SRCS_EXT+= ExecutionEngine/Orc/ObjectTransformLayer.cpp
SRCS_EXT+= ExecutionEngine/Orc/OrcABISupport.cpp
SRCS_EXT+= ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp
SRCS_EXT+= ExecutionEngine/Orc/Shared/AllocationActions.cpp
SRCS_EXT+= ExecutionEngine/Orc/Shared/OrcError.cpp
SRCS_EXT+= ExecutionEngine/Orc/Shared/OrcRTBridge.cpp
SRCS_EXT+= ExecutionEngine/Orc/Shared/SimpleRemoteEPCUtils.cpp
SRCS_EXT+= ExecutionEngine/Orc/SimpleRemoteEPC.cpp
SRCS_EXT+= ExecutionEngine/Orc/Speculation.cpp
SRCS_XDB+= ExecutionEngine/Orc/TargetProcess/JITLoaderGDB.cpp
SRCS_EXT+= ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.cpp
SRCS_EXT+= ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.cpp
SRCS_EXT+= ExecutionEngine/Orc/TaskDispatch.cpp
SRCS_EXT+= ExecutionEngine/Orc/ThreadSafeModule.cpp
SRCS_XDB+= ExecutionEngine/RuntimeDyld/JITSymbol.cpp
SRCS_XDB+= ExecutionEngine/RuntimeDyld/RTDyldMemoryManager.cpp
SRCS_XDB+= ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
SRCS_XDB+= ExecutionEngine/RuntimeDyld/RuntimeDyldCOFF.cpp
SRCS_XDB+= ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp
SRCS_XDB+= ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp
SRCS_XDB+= ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp
SRCS_XDB+= ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldELFMips.cpp
SRCS_XDB+= ExecutionEngine/SectionMemoryManager.cpp
SRCS_XDB+= ExecutionEngine/TargetSelect.cpp
SRCS_MIN+= Frontend/OpenMP/OMP.cpp
SRCS_MIN+= Frontend/OpenMP/OMPContext.cpp
SRCS_MIN+= Frontend/OpenMP/OMPIRBuilder.cpp
SRCS_MIN+= IR/AbstractCallSite.cpp
SRCS_MIN+= IR/AsmWriter.cpp
SRCS_MIN+= IR/Assumptions.cpp
SRCS_MIN+= IR/Attributes.cpp
SRCS_MIN+= IR/AutoUpgrade.cpp
SRCS_MIN+= IR/BasicBlock.cpp
SRCS_EXT+= IR/BuiltinGCs.cpp
SRCS_MIN+= IR/Comdat.cpp
SRCS_MIN+= IR/ConstantFold.cpp
SRCS_MIN+= IR/ConstantRange.cpp
SRCS_MIN+= IR/Constants.cpp
SRCS_MIN+= IR/Core.cpp
SRCS_MIN+= IR/DIBuilder.cpp
SRCS_MIN+= IR/DataLayout.cpp
SRCS_MIN+= IR/DebugInfo.cpp
SRCS_MIN+= IR/DebugInfoMetadata.cpp
SRCS_MIN+= IR/DebugLoc.cpp
SRCS_MIN+= IR/DiagnosticHandler.cpp
SRCS_MIN+= IR/DiagnosticInfo.cpp
SRCS_MIN+= IR/DiagnosticPrinter.cpp
SRCS_MIN+= IR/Dominators.cpp
SRCS_MIN+= IR/FPEnv.cpp
SRCS_MIN+= IR/Function.cpp
SRCS_MIN+= IR/GCStrategy.cpp
SRCS_MIN+= IR/GVMaterializer.cpp
SRCS_MIN+= IR/Globals.cpp
SRCS_MIN+= IR/IRBuilder.cpp
SRCS_MIN+= IR/IRPrintingPasses.cpp
SRCS_MIN+= IR/InlineAsm.cpp
SRCS_MIN+= IR/Instruction.cpp
SRCS_MIN+= IR/Instructions.cpp
SRCS_MIN+= IR/IntrinsicInst.cpp
SRCS_MIN+= IR/LLVMContext.cpp
SRCS_MIN+= IR/LLVMContextImpl.cpp
SRCS_MIN+= IR/LLVMRemarkStreamer.cpp
SRCS_MIN+= IR/LegacyPassManager.cpp
SRCS_MIN+= IR/MDBuilder.cpp
SRCS_MIN+= IR/Mangler.cpp
SRCS_MIN+= IR/Metadata.cpp
SRCS_MIN+= IR/Module.cpp
SRCS_MIN+= IR/ModuleSummaryIndex.cpp
SRCS_MIN+= IR/Operator.cpp
SRCS_MIN+= IR/OptBisect.cpp
SRCS_MIN+= IR/Pass.cpp
SRCS_MIN+= IR/PassInstrumentation.cpp
SRCS_MIN+= IR/PassManager.cpp
SRCS_MIN+= IR/PassRegistry.cpp
SRCS_MIN+= IR/PassTimingInfo.cpp
SRCS_MIN+= IR/PrintPasses.cpp
SRCS_MIN+= IR/ProfileSummary.cpp
SRCS_MIN+= IR/PseudoProbe.cpp
SRCS_MIN+= IR/ReplaceConstant.cpp
SRCS_MIN+= IR/SSAContext.cpp
SRCS_MIN+= IR/SafepointIRVerifier.cpp
SRCS_MIN+= IR/Statepoint.cpp
SRCS_MIN+= IR/Type.cpp
SRCS_MIN+= IR/TypeFinder.cpp
SRCS_MIN+= IR/Use.cpp
SRCS_MIN+= IR/User.cpp
SRCS_MIN+= IR/Value.cpp
SRCS_MIN+= IR/ValueSymbolTable.cpp
SRCS_MIN+= IR/Verifier.cpp
SRCS_MIN+= IRReader/IRReader.cpp
SRCS_MIN+= LTO/LTO.cpp
SRCS_MIN+= LTO/LTOBackend.cpp
SRCS_EXL+= LTO/LTOCodeGenerator.cpp
SRCS_EXL+= LTO/LTOModule.cpp
SRCS_EXL+= LTO/SummaryBasedOptimizations.cpp
SRCS_EXL+= LTO/ThinLTOCodeGenerator.cpp
SRCS_MIN+= LTO/UpdateCompilerUsed.cpp
# Only needed for clangd/clang-query, uncomment once we build those.
# SRCS_XDW+= LineEditor/LineEditor.cpp
SRCS_MIN+= Linker/IRMover.cpp
SRCS_MIN+= Linker/LinkModules.cpp
SRCS_MIN+= MC/ConstantPools.cpp
SRCS_MIN+= MC/ELFObjectWriter.cpp
SRCS_MIN+= MC/MCAsmBackend.cpp
SRCS_MIN+= MC/MCAsmInfo.cpp
SRCS_MIN+= MC/MCAsmInfoCOFF.cpp
SRCS_MIN+= MC/MCAsmInfoDarwin.cpp
SRCS_MIN+= MC/MCAsmInfoELF.cpp
SRCS_MIN+= MC/MCAsmInfoXCOFF.cpp
SRCS_MIN+= MC/MCAsmMacro.cpp
SRCS_MIN+= MC/MCAsmStreamer.cpp
SRCS_MIN+= MC/MCAssembler.cpp
SRCS_MIN+= MC/MCCodeEmitter.cpp
SRCS_MIN+= MC/MCCodeView.cpp
SRCS_MIN+= MC/MCContext.cpp
SRCS_XDL+= MC/MCDisassembler/Disassembler.cpp
SRCS_XDW+= MC/MCDisassembler/MCDisassembler.cpp
SRCS_XDW+= MC/MCDisassembler/MCExternalSymbolizer.cpp
SRCS_MIN+= MC/MCDisassembler/MCRelocationInfo.cpp
SRCS_XDW+= MC/MCDisassembler/MCSymbolizer.cpp
SRCS_MIN+= MC/MCDwarf.cpp
SRCS_MIN+= MC/MCELFObjectTargetWriter.cpp
SRCS_MIN+= MC/MCELFStreamer.cpp
SRCS_MIN+= MC/MCExpr.cpp
SRCS_MIN+= MC/MCFragment.cpp
SRCS_MIN+= MC/MCInst.cpp
SRCS_MIN+= MC/MCInstPrinter.cpp
SRCS_MIN+= MC/MCInstrAnalysis.cpp
SRCS_MIN+= MC/MCInstrDesc.cpp
SRCS_MIN+= MC/MCInstrInfo.cpp
SRCS_MIN+= MC/MCLinkerOptimizationHint.cpp
SRCS_MIN+= MC/MCMachOStreamer.cpp
SRCS_MIN+= MC/MCMachObjectTargetWriter.cpp
SRCS_MIN+= MC/MCNullStreamer.cpp
SRCS_MIN+= MC/MCObjectFileInfo.cpp
SRCS_MIN+= MC/MCObjectStreamer.cpp
SRCS_MIN+= MC/MCObjectWriter.cpp
SRCS_MIN+= MC/MCParser/AsmLexer.cpp
SRCS_MIN+= MC/MCParser/AsmParser.cpp
SRCS_MIN+= MC/MCParser/COFFAsmParser.cpp
SRCS_MIN+= MC/MCParser/DarwinAsmParser.cpp
SRCS_MIN+= MC/MCParser/ELFAsmParser.cpp
SRCS_MIN+= MC/MCParser/GOFFAsmParser.cpp
SRCS_MIN+= MC/MCParser/MCAsmLexer.cpp
SRCS_MIN+= MC/MCParser/MCAsmParser.cpp
SRCS_MIN+= MC/MCParser/MCAsmParserExtension.cpp
SRCS_MIN+= MC/MCParser/MCTargetAsmParser.cpp
SRCS_MIN+= MC/MCParser/WasmAsmParser.cpp
SRCS_MIN+= MC/MCParser/XCOFFAsmParser.cpp
SRCS_MIN+= MC/MCPseudoProbe.cpp
SRCS_MIN+= MC/MCRegisterInfo.cpp
SRCS_MIN+= MC/MCSchedule.cpp
SRCS_MIN+= MC/MCSection.cpp
SRCS_MIN+= MC/MCSectionCOFF.cpp
SRCS_MIN+= MC/MCSectionELF.cpp
SRCS_MIN+= MC/MCSectionMachO.cpp
SRCS_MIN+= MC/MCSectionWasm.cpp
SRCS_MIN+= MC/MCSectionXCOFF.cpp
SRCS_MIN+= MC/MCStreamer.cpp
SRCS_MIN+= MC/MCSubtargetInfo.cpp
SRCS_MIN+= MC/MCSymbol.cpp
SRCS_MIN+= MC/MCSymbolELF.cpp
SRCS_MIN+= MC/MCSymbolXCOFF.cpp
SRCS_MIN+= MC/MCTargetOptions.cpp
SRCS_MIN+= MC/MCTargetOptionsCommandFlags.cpp
SRCS_MIN+= MC/MCValue.cpp
SRCS_MIN+= MC/MCWasmStreamer.cpp
SRCS_MIN+= MC/MCWin64EH.cpp
SRCS_MIN+= MC/MCWinCOFFStreamer.cpp
SRCS_MIN+= MC/MCWinEH.cpp
SRCS_MIN+= MC/MCXCOFFStreamer.cpp
SRCS_MIN+= MC/MCXCOFFObjectTargetWriter.cpp
SRCS_MIN+= MC/MachObjectWriter.cpp
SRCS_MIN+= MC/StringTableBuilder.cpp
SRCS_MIN+= MC/SubtargetFeature.cpp
SRCS_MIN+= MC/TargetRegistry.cpp
SRCS_MIN+= MC/WasmObjectWriter.cpp
SRCS_MIN+= MC/WinCOFFObjectWriter.cpp
SRCS_MIN+= MC/XCOFFObjectWriter.cpp
SRCS_EXT+= MCA/CodeEmitter.cpp
SRCS_EXT+= MCA/Context.cpp
SRCS_EXT+= MCA/CustomBehaviour.cpp
SRCS_EXT+= MCA/HWEventListener.cpp
SRCS_EXT+= MCA/HardwareUnits/HardwareUnit.cpp
SRCS_EXT+= MCA/HardwareUnits/LSUnit.cpp
SRCS_EXT+= MCA/HardwareUnits/RegisterFile.cpp
SRCS_EXT+= MCA/HardwareUnits/ResourceManager.cpp
SRCS_EXT+= MCA/HardwareUnits/RetireControlUnit.cpp
SRCS_EXT+= MCA/HardwareUnits/Scheduler.cpp
SRCS_EXT+= MCA/InstrBuilder.cpp
SRCS_EXT+= MCA/Instruction.cpp
SRCS_EXT+= MCA/Pipeline.cpp
SRCS_EXT+= MCA/Stages/DispatchStage.cpp
SRCS_EXT+= MCA/Stages/EntryStage.cpp
SRCS_EXT+= MCA/Stages/ExecuteStage.cpp
SRCS_EXT+= MCA/Stages/InOrderIssueStage.cpp
SRCS_EXT+= MCA/Stages/InstructionTables.cpp
SRCS_EXT+= MCA/Stages/MicroOpQueueStage.cpp
SRCS_EXT+= MCA/Stages/RetireStage.cpp
SRCS_EXT+= MCA/Stages/Stage.cpp
SRCS_EXT+= MCA/Support.cpp
SRCS_EXT+= MCA/View.cpp
SRCS_MIN+= Object/Archive.cpp
SRCS_MIN+= Object/ArchiveWriter.cpp
SRCS_MIN+= Object/Binary.cpp
SRCS_MIN+= Object/COFFImportFile.cpp
SRCS_MIW+= Object/COFFModuleDefinition.cpp
SRCS_MIN+= Object/COFFObjectFile.cpp
SRCS_MIN+= Object/Decompressor.cpp
SRCS_MIN+= Object/ELF.cpp
SRCS_MIN+= Object/ELFObjectFile.cpp
SRCS_MIN+= Object/Error.cpp
SRCS_MIW+= Object/FaultMapParser.cpp
SRCS_MIN+= Object/IRObjectFile.cpp
SRCS_MIN+= Object/IRSymtab.cpp
SRCS_MIN+= Object/MachOObjectFile.cpp
SRCS_MIW+= Object/MachOUniversal.cpp
SRCS_MIW+= Object/MachOUniversalWriter.cpp
SRCS_MIW+= Object/Minidump.cpp
SRCS_MIN+= Object/ModuleSymbolTable.cpp
SRCS_EXT+= Object/Object.cpp
SRCS_MIN+= Object/ObjectFile.cpp
SRCS_MIN+= Object/RecordStreamer.cpp
SRCS_MIW+= Object/RelocationResolver.cpp
SRCS_MIW+= Object/SymbolSize.cpp
SRCS_MIN+= Object/SymbolicFile.cpp
SRCS_MIW+= Object/TapiFile.cpp
SRCS_MIW+= Object/TapiUniversal.cpp
SRCS_MIN+= Object/WasmObjectFile.cpp
SRCS_MIW+= Object/WindowsMachineFlag.cpp
SRCS_MIN+= Object/WindowsResource.cpp
SRCS_MIN+= Object/XCOFFObjectFile.cpp
SRCS_MIN+= ObjectYAML/COFFYAML.cpp
SRCS_EXT+= ObjectYAML/CodeViewYAMLDebugSections.cpp
SRCS_EXT+= ObjectYAML/CodeViewYAMLSymbols.cpp
SRCS_EXT+= ObjectYAML/CodeViewYAMLTypes.cpp
SRCS_MIN+= ObjectYAML/DWARFYAML.cpp
SRCS_MIN+= ObjectYAML/ELFYAML.cpp
SRCS_MIN+= ObjectYAML/MachOYAML.cpp
SRCS_EXT+= ObjectYAML/YAML.cpp
SRCS_MIN+= Option/Arg.cpp
SRCS_MIN+= Option/ArgList.cpp
SRCS_MIN+= Option/OptTable.cpp
SRCS_MIN+= Option/Option.cpp
SRCS_MIN+= Passes/OptimizationLevel.cpp
SRCS_MIN+= Passes/PassBuilder.cpp
SRCS_MIN+= Passes/PassBuilderPipelines.cpp
SRCS_MIN+= Passes/PassPlugin.cpp
SRCS_MIN+= Passes/StandardInstrumentations.cpp
SRCS_MIN+= ProfileData/Coverage/CoverageMapping.cpp
SRCS_MIN+= ProfileData/Coverage/CoverageMappingReader.cpp
SRCS_MIN+= ProfileData/Coverage/CoverageMappingWriter.cpp
SRCS_MIN+= ProfileData/GCOV.cpp
SRCS_MIN+= ProfileData/InstrProf.cpp
SRCS_MIN+= ProfileData/InstrProfCorrelator.cpp
SRCS_MIN+= ProfileData/InstrProfReader.cpp
SRCS_MIN+= ProfileData/InstrProfWriter.cpp
SRCS_MIN+= ProfileData/ProfileSummaryBuilder.cpp
-SRCS_EXT+= ProfileData/RawMemProfReader.cpp
+SRCS_MIW+= ProfileData/RawMemProfReader.cpp
SRCS_MIN+= ProfileData/SampleProf.cpp
SRCS_MIN+= ProfileData/SampleProfReader.cpp
SRCS_MIN+= ProfileData/SampleProfWriter.cpp
SRCS_MIN+= Remarks/BitstreamRemarkParser.cpp
SRCS_MIN+= Remarks/BitstreamRemarkSerializer.cpp
SRCS_MIN+= Remarks/RemarkFormat.cpp
SRCS_MIN+= Remarks/RemarkParser.cpp
SRCS_MIN+= Remarks/RemarkSerializer.cpp
SRCS_MIN+= Remarks/RemarkStreamer.cpp
SRCS_MIN+= Remarks/RemarkStringTable.cpp
SRCS_MIN+= Remarks/YAMLRemarkParser.cpp
SRCS_MIN+= Remarks/YAMLRemarkSerializer.cpp
SRCS_MIN+= Support/AArch64TargetParser.cpp
SRCS_MIN+= Support/ABIBreak.cpp
SRCS_MIN+= Support/APFixedPoint.cpp
SRCS_MIN+= Support/APFloat.cpp
SRCS_MIN+= Support/APInt.cpp
SRCS_MIN+= Support/APSInt.cpp
SRCS_MIN+= Support/ARMAttributeParser.cpp
SRCS_MIN+= Support/ARMBuildAttrs.cpp
SRCS_MIN+= Support/ARMTargetParser.cpp
SRCS_MIN+= Support/ARMWinEH.cpp
SRCS_MIN+= Support/Allocator.cpp
SRCS_MIN+= Support/BinaryStreamError.cpp
SRCS_MIN+= Support/BinaryStreamReader.cpp
SRCS_MIN+= Support/BinaryStreamRef.cpp
SRCS_MIN+= Support/BinaryStreamWriter.cpp
SRCS_MIN+= Support/BlockFrequency.cpp
SRCS_MIN+= Support/BranchProbability.cpp
SRCS_MIN+= Support/BuryPointer.cpp
SRCS_MIN+= Support/CachePruning.cpp
SRCS_MIW+= Support/Caching.cpp
SRCS_MIW+= Support/COM.cpp
SRCS_MIN+= Support/CRC.cpp
SRCS_MIN+= Support/Chrono.cpp
SRCS_MIN+= Support/CodeGenCoverage.cpp
SRCS_MIN+= Support/CommandLine.cpp
SRCS_MIN+= Support/Compression.cpp
SRCS_MIN+= Support/ConvertUTF.cpp
SRCS_MIN+= Support/ConvertUTFWrapper.cpp
SRCS_MIN+= Support/CrashRecoveryContext.cpp
SRCS_MIN+= Support/DAGDeltaAlgorithm.cpp
SRCS_MIN+= Support/DJB.cpp
SRCS_MIN+= Support/DataExtractor.cpp
SRCS_MIN+= Support/Debug.cpp
SRCS_MIN+= Support/DebugCounter.cpp
SRCS_MIN+= Support/DeltaAlgorithm.cpp
SRCS_MIN+= Support/DivisionByConstantInfo.cpp
SRCS_MIN+= Support/DynamicLibrary.cpp
SRCS_MIN+= Support/ELFAttributeParser.cpp
SRCS_MIN+= Support/ELFAttributes.cpp
SRCS_MIN+= Support/Errno.cpp
SRCS_MIN+= Support/Error.cpp
SRCS_MIN+= Support/ErrorHandling.cpp
SRCS_MIN+= Support/ExtensibleRTTI.cpp
SRCS_MIN+= Support/FileCollector.cpp
SRCS_MIW+= Support/FileOutputBuffer.cpp
SRCS_MIN+= Support/FileUtilities.cpp
SRCS_MIN+= Support/FoldingSet.cpp
SRCS_MIN+= Support/FormatVariadic.cpp
SRCS_MIN+= Support/FormattedStream.cpp
SRCS_MIN+= Support/GlobPattern.cpp
SRCS_MIN+= Support/GraphWriter.cpp
SRCS_MIN+= Support/Hashing.cpp
SRCS_MIN+= Support/Host.cpp
SRCS_MIN+= Support/InitLLVM.cpp
SRCS_MIN+= Support/InstructionCost.cpp
SRCS_MIN+= Support/IntEqClasses.cpp
SRCS_MIN+= Support/IntervalMap.cpp
SRCS_MIN+= Support/ItaniumManglingCanonicalizer.cpp
SRCS_MIN+= Support/JSON.cpp
SRCS_MIN+= Support/KnownBits.cpp
SRCS_MIN+= Support/LEB128.cpp
SRCS_MIN+= Support/LineIterator.cpp
SRCS_MIN+= Support/Locale.cpp
SRCS_MIN+= Support/LockFileManager.cpp
SRCS_MIN+= Support/LowLevelType.cpp
SRCS_MIN+= Support/MD5.cpp
SRCS_MIW+= Support/MSP430AttributeParser.cpp
SRCS_MIW+= Support/MSP430Attributes.cpp
SRCS_MIN+= Support/ManagedStatic.cpp
SRCS_MIN+= Support/MathExtras.cpp
SRCS_MIN+= Support/MemAlloc.cpp
SRCS_MIW+= Support/Memory.cpp
SRCS_MIN+= Support/MemoryBuffer.cpp
SRCS_MIN+= Support/MemoryBufferRef.cpp
SRCS_MIN+= Support/NativeFormatting.cpp
SRCS_MIN+= Support/OptimizedStructLayout.cpp
SRCS_MIN+= Support/Optional.cpp
SRCS_EXL+= Support/Parallel.cpp
SRCS_MIN+= Support/Path.cpp
SRCS_MIN+= Support/PluginLoader.cpp
SRCS_MIN+= Support/PrettyStackTrace.cpp
SRCS_MIN+= Support/Process.cpp
SRCS_MIN+= Support/Program.cpp
SRCS_MIN+= Support/RISCVAttributeParser.cpp
SRCS_MIN+= Support/RISCVAttributes.cpp
SRCS_MIN+= Support/RISCVISAInfo.cpp
SRCS_MIN+= Support/RWMutex.cpp
SRCS_MIN+= Support/RandomNumberGenerator.cpp
SRCS_MIN+= Support/Regex.cpp
SRCS_MIN+= Support/SHA1.cpp
SRCS_MIN+= Support/SHA256.cpp
SRCS_MIN+= Support/ScaledNumber.cpp
SRCS_MIN+= Support/ScopedPrinter.cpp
SRCS_MIN+= Support/Signals.cpp
SRCS_MIN+= Support/Signposts.cpp
SRCS_MIN+= Support/SmallPtrSet.cpp
SRCS_MIN+= Support/SmallVector.cpp
SRCS_MIN+= Support/SourceMgr.cpp
SRCS_MIN+= Support/SpecialCaseList.cpp
SRCS_MIN+= Support/Statistic.cpp
SRCS_MIN+= Support/StringExtras.cpp
SRCS_MIN+= Support/StringMap.cpp
SRCS_MIN+= Support/StringRef.cpp
SRCS_MIN+= Support/StringSaver.cpp
SRCS_MIN+= Support/SuffixTree.cpp
SRCS_MIN+= Support/SymbolRemappingReader.cpp
SRCS_EXT+= Support/SystemUtils.cpp
SRCS_LLD+= Support/TarWriter.cpp
SRCS_MIN+= Support/TargetParser.cpp
SRCS_MIN+= Support/ThreadLocal.cpp
SRCS_MIW+= Support/ThreadPool.cpp
SRCS_MIN+= Support/Threading.cpp
SRCS_MIN+= Support/TimeProfiler.cpp
SRCS_MIN+= Support/Timer.cpp
SRCS_MIN+= Support/ToolOutputFile.cpp
SRCS_MIN+= Support/TrigramIndex.cpp
SRCS_MIN+= Support/Triple.cpp
SRCS_MIN+= Support/Twine.cpp
SRCS_MIN+= Support/TypeSize.cpp
SRCS_MIN+= Support/Unicode.cpp
SRCS_MIN+= Support/UnicodeCaseFold.cpp
SRCS_MIN+= Support/Valgrind.cpp
SRCS_MIN+= Support/VirtualFileSystem.cpp
SRCS_MIN+= Support/VersionTuple.cpp
SRCS_MIN+= Support/Watchdog.cpp
SRCS_MIN+= Support/WithColor.cpp
SRCS_MIN+= Support/X86TargetParser.cpp
SRCS_MIN+= Support/YAMLParser.cpp
SRCS_MIN+= Support/YAMLTraits.cpp
SRCS_FUL+= Support/Z3Solver.cpp
SRCS_MIN+= Support/circular_raw_ostream.cpp
SRCS_MIN+= Support/raw_os_ostream.cpp
SRCS_MIN+= Support/raw_ostream.cpp
SRCS_MIN+= Support/regcomp.c
SRCS_MIN+= Support/regerror.c
SRCS_MIN+= Support/regexec.c
SRCS_MIN+= Support/regfree.c
SRCS_MIN+= Support/regstrlcpy.c
SRCS_MIN+= Support/xxhash.cpp
SRCS_MIN+= TableGen/DetailedRecordsBackend.cpp
SRCS_MIN+= TableGen/Error.cpp
SRCS_MIN+= TableGen/JSONBackend.cpp
SRCS_MIN+= TableGen/Main.cpp
SRCS_MIN+= TableGen/Record.cpp
SRCS_MIN+= TableGen/SetTheory.cpp
SRCS_MIN+= TableGen/StringMatcher.cpp
SRCS_MIN+= TableGen/TGLexer.cpp
SRCS_MIN+= TableGen/TGParser.cpp
SRCS_MIN+= TableGen/TableGenBackend.cpp
.if ${MK_LLVM_TARGET_AARCH64} != "no"
SRCS_MIN+= Target/AArch64/AArch64A53Fix835769.cpp
SRCS_MIN+= Target/AArch64/AArch64A57FPLoadBalancing.cpp
SRCS_MIN+= Target/AArch64/AArch64AdvSIMDScalarPass.cpp
SRCS_MIN+= Target/AArch64/AArch64AsmPrinter.cpp
SRCS_MIN+= Target/AArch64/AArch64BranchTargets.cpp
SRCS_MIN+= Target/AArch64/AArch64CallingConvention.cpp
SRCS_MIN+= Target/AArch64/AArch64CleanupLocalDynamicTLSPass.cpp
SRCS_MIN+= Target/AArch64/AArch64CollectLOH.cpp
SRCS_MIN+= Target/AArch64/AArch64CompressJumpTables.cpp
SRCS_MIN+= Target/AArch64/AArch64CondBrTuning.cpp
SRCS_MIN+= Target/AArch64/AArch64ConditionOptimizer.cpp
SRCS_MIN+= Target/AArch64/AArch64ConditionalCompares.cpp
SRCS_MIN+= Target/AArch64/AArch64DeadRegisterDefinitionsPass.cpp
SRCS_MIN+= Target/AArch64/AArch64ExpandImm.cpp
SRCS_MIN+= Target/AArch64/AArch64ExpandPseudoInsts.cpp
SRCS_MIN+= Target/AArch64/AArch64FalkorHWPFFix.cpp
SRCS_MIN+= Target/AArch64/AArch64FastISel.cpp
SRCS_MIN+= Target/AArch64/AArch64FrameLowering.cpp
SRCS_MIN+= Target/AArch64/AArch64ISelDAGToDAG.cpp
SRCS_MIN+= Target/AArch64/AArch64ISelLowering.cpp
SRCS_MIN+= Target/AArch64/AArch64InstrInfo.cpp
SRCS_MIN+= Target/AArch64/AArch64LoadStoreOptimizer.cpp
SRCS_MIN+= Target/AArch64/AArch64LowerHomogeneousPrologEpilog.cpp
SRCS_MIN+= Target/AArch64/AArch64MCInstLower.cpp
SRCS_MIN+= Target/AArch64/AArch64MIPeepholeOpt.cpp
SRCS_MIN+= Target/AArch64/AArch64MachineFunctionInfo.cpp
SRCS_MIN+= Target/AArch64/AArch64MacroFusion.cpp
SRCS_MIN+= Target/AArch64/AArch64PBQPRegAlloc.cpp
SRCS_MIN+= Target/AArch64/AArch64PromoteConstant.cpp
SRCS_MIN+= Target/AArch64/AArch64RedundantCopyElimination.cpp
SRCS_MIN+= Target/AArch64/AArch64RegisterInfo.cpp
SRCS_MIN+= Target/AArch64/AArch64SIMDInstrOpt.cpp
SRCS_MIN+= Target/AArch64/AArch64SLSHardening.cpp
SRCS_MIN+= Target/AArch64/AArch64SelectionDAGInfo.cpp
SRCS_MIN+= Target/AArch64/AArch64SpeculationHardening.cpp
SRCS_MIN+= Target/AArch64/AArch64StackTagging.cpp
SRCS_MIN+= Target/AArch64/AArch64StackTaggingPreRA.cpp
SRCS_MIN+= Target/AArch64/AArch64StorePairSuppress.cpp
SRCS_MIN+= Target/AArch64/AArch64Subtarget.cpp
SRCS_MIN+= Target/AArch64/AArch64TargetMachine.cpp
SRCS_MIN+= Target/AArch64/AArch64TargetObjectFile.cpp
SRCS_MIN+= Target/AArch64/AArch64TargetTransformInfo.cpp
SRCS_MIN+= Target/AArch64/AsmParser/AArch64AsmParser.cpp
SRCS_XDW+= Target/AArch64/Disassembler/AArch64Disassembler.cpp
SRCS_XDW+= Target/AArch64/Disassembler/AArch64ExternalSymbolizer.cpp
SRCS_MIN+= Target/AArch64/GISel/AArch64CallLowering.cpp
SRCS_MIN+= Target/AArch64/GISel/AArch64GlobalISelUtils.cpp
SRCS_MIN+= Target/AArch64/GISel/AArch64InstructionSelector.cpp
SRCS_MIN+= Target/AArch64/GISel/AArch64LegalizerInfo.cpp
SRCS_MIN+= Target/AArch64/GISel/AArch64O0PreLegalizerCombiner.cpp
SRCS_MIN+= Target/AArch64/GISel/AArch64PreLegalizerCombiner.cpp
SRCS_MIN+= Target/AArch64/GISel/AArch64PostLegalizerCombiner.cpp
SRCS_MIN+= Target/AArch64/GISel/AArch64PostLegalizerLowering.cpp
SRCS_MIN+= Target/AArch64/GISel/AArch64PostSelectOptimize.cpp
SRCS_MIN+= Target/AArch64/GISel/AArch64RegisterBankInfo.cpp
SRCS_MIN+= Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp
SRCS_MIN+= Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp
SRCS_MIN+= Target/AArch64/MCTargetDesc/AArch64ELFStreamer.cpp
SRCS_MIN+= Target/AArch64/MCTargetDesc/AArch64InstPrinter.cpp
SRCS_MIN+= Target/AArch64/MCTargetDesc/AArch64MCAsmInfo.cpp
SRCS_MIN+= Target/AArch64/MCTargetDesc/AArch64MCCodeEmitter.cpp
SRCS_MIN+= Target/AArch64/MCTargetDesc/AArch64MCExpr.cpp
SRCS_MIN+= Target/AArch64/MCTargetDesc/AArch64MCTargetDesc.cpp
SRCS_MIN+= Target/AArch64/MCTargetDesc/AArch64MachObjectWriter.cpp
SRCS_MIN+= Target/AArch64/MCTargetDesc/AArch64TargetStreamer.cpp
SRCS_MIN+= Target/AArch64/MCTargetDesc/AArch64WinCOFFObjectWriter.cpp
SRCS_MIN+= Target/AArch64/MCTargetDesc/AArch64WinCOFFStreamer.cpp
SRCS_MIN+= Target/AArch64/SVEIntrinsicOpts.cpp
SRCS_MIN+= Target/AArch64/TargetInfo/AArch64TargetInfo.cpp
SRCS_MIN+= Target/AArch64/Utils/AArch64BaseInfo.cpp
.endif # MK_LLVM_TARGET_AARCH64
.if ${MK_LLVM_TARGET_ARM} != "no"
SRCS_MIN+= Target/ARM/A15SDOptimizer.cpp
SRCS_MIN+= Target/ARM/ARMAsmPrinter.cpp
SRCS_MIN+= Target/ARM/ARMBaseInstrInfo.cpp
SRCS_MIN+= Target/ARM/ARMBaseRegisterInfo.cpp
SRCS_MIN+= Target/ARM/ARMBasicBlockInfo.cpp
SRCS_MIN+= Target/ARM/ARMBlockPlacement.cpp
SRCS_MIN+= Target/ARM/ARMBranchTargets.cpp
SRCS_MIN+= Target/ARM/ARMCallLowering.cpp
SRCS_MIN+= Target/ARM/ARMCallingConv.cpp
SRCS_MIN+= Target/ARM/ARMConstantIslandPass.cpp
SRCS_MIN+= Target/ARM/ARMConstantPoolValue.cpp
SRCS_MIN+= Target/ARM/ARMExpandPseudoInsts.cpp
SRCS_MIN+= Target/ARM/ARMFastISel.cpp
SRCS_MIN+= Target/ARM/ARMFrameLowering.cpp
SRCS_MIN+= Target/ARM/ARMHazardRecognizer.cpp
SRCS_MIN+= Target/ARM/ARMISelDAGToDAG.cpp
SRCS_MIN+= Target/ARM/ARMISelLowering.cpp
SRCS_MIN+= Target/ARM/ARMInstrInfo.cpp
SRCS_MIN+= Target/ARM/ARMInstructionSelector.cpp
SRCS_MIN+= Target/ARM/ARMLegalizerInfo.cpp
SRCS_MIN+= Target/ARM/ARMLoadStoreOptimizer.cpp
SRCS_MIN+= Target/ARM/ARMLowOverheadLoops.cpp
SRCS_MIN+= Target/ARM/ARMMCInstLower.cpp
SRCS_MIN+= Target/ARM/ARMMachineFunctionInfo.cpp
SRCS_MIN+= Target/ARM/ARMMacroFusion.cpp
SRCS_MIN+= Target/ARM/ARMOptimizeBarriersPass.cpp
SRCS_MIN+= Target/ARM/ARMParallelDSP.cpp
SRCS_MIN+= Target/ARM/ARMRegisterBankInfo.cpp
SRCS_MIN+= Target/ARM/ARMRegisterInfo.cpp
SRCS_MIN+= Target/ARM/ARMSLSHardening.cpp
SRCS_MIN+= Target/ARM/ARMSelectionDAGInfo.cpp
SRCS_MIN+= Target/ARM/ARMSubtarget.cpp
SRCS_MIN+= Target/ARM/ARMTargetMachine.cpp
SRCS_MIN+= Target/ARM/ARMTargetObjectFile.cpp
SRCS_MIN+= Target/ARM/ARMTargetTransformInfo.cpp
SRCS_MIN+= Target/ARM/AsmParser/ARMAsmParser.cpp
SRCS_MIN+= Target/ARM/Disassembler/ARMDisassembler.cpp
SRCS_MIN+= Target/ARM/MCTargetDesc/ARMAsmBackend.cpp
SRCS_MIN+= Target/ARM/MCTargetDesc/ARMELFObjectWriter.cpp
SRCS_MIN+= Target/ARM/MCTargetDesc/ARMELFStreamer.cpp
SRCS_MIN+= Target/ARM/MCTargetDesc/ARMInstPrinter.cpp
SRCS_MIN+= Target/ARM/MCTargetDesc/ARMMCAsmInfo.cpp
SRCS_MIN+= Target/ARM/MCTargetDesc/ARMMCCodeEmitter.cpp
SRCS_MIN+= Target/ARM/MCTargetDesc/ARMMCExpr.cpp
SRCS_MIN+= Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp
SRCS_MIN+= Target/ARM/MCTargetDesc/ARMMachORelocationInfo.cpp
SRCS_MIN+= Target/ARM/MCTargetDesc/ARMMachObjectWriter.cpp
SRCS_MIN+= Target/ARM/MCTargetDesc/ARMTargetStreamer.cpp
SRCS_MIN+= Target/ARM/MCTargetDesc/ARMUnwindOpAsm.cpp
SRCS_MIN+= Target/ARM/MCTargetDesc/ARMWinCOFFObjectWriter.cpp
SRCS_MIN+= Target/ARM/MCTargetDesc/ARMWinCOFFStreamer.cpp
SRCS_MIN+= Target/ARM/MLxExpansionPass.cpp
SRCS_MIN+= Target/ARM/MVEGatherScatterLowering.cpp
SRCS_MIN+= Target/ARM/MVELaneInterleavingPass.cpp
SRCS_MIN+= Target/ARM/MVETPAndVPTOptimisationsPass.cpp
SRCS_MIN+= Target/ARM/MVETailPredication.cpp
SRCS_MIN+= Target/ARM/MVEVPTBlockPass.cpp
SRCS_MIN+= Target/ARM/TargetInfo/ARMTargetInfo.cpp
SRCS_MIN+= Target/ARM/Thumb1FrameLowering.cpp
SRCS_MIN+= Target/ARM/Thumb1InstrInfo.cpp
SRCS_MIN+= Target/ARM/Thumb2ITBlockPass.cpp
SRCS_MIN+= Target/ARM/Thumb2InstrInfo.cpp
SRCS_MIN+= Target/ARM/Thumb2SizeReduction.cpp
SRCS_MIN+= Target/ARM/ThumbRegisterInfo.cpp
SRCS_MIN+= Target/ARM/Utils/ARMBaseInfo.cpp
.endif # MK_LLVM_TARGET_ARM
.if ${MK_LLVM_TARGET_BPF} != "no"
SRCS_MIN+= Target/BPF/AsmParser/BPFAsmParser.cpp
SRCS_MIN+= Target/BPF/BPFAbstractMemberAccess.cpp
SRCS_MIN+= Target/BPF/BPFAdjustOpt.cpp
SRCS_MIN+= Target/BPF/BPFAsmPrinter.cpp
SRCS_MIN+= Target/BPF/BPFCheckAndAdjustIR.cpp
SRCS_MIN+= Target/BPF/BPFFrameLowering.cpp
SRCS_MIN+= Target/BPF/BPFIRPeephole.cpp
SRCS_MIN+= Target/BPF/BPFISelDAGToDAG.cpp
SRCS_MIN+= Target/BPF/BPFISelLowering.cpp
SRCS_MIN+= Target/BPF/BPFInstrInfo.cpp
SRCS_MIN+= Target/BPF/BPFMCInstLower.cpp
SRCS_MIN+= Target/BPF/BPFMIChecking.cpp
SRCS_MIN+= Target/BPF/BPFMIPeephole.cpp
SRCS_MIN+= Target/BPF/BPFMISimplifyPatchable.cpp
SRCS_MIN+= Target/BPF/BPFPreserveDIType.cpp
SRCS_MIN+= Target/BPF/BPFRegisterInfo.cpp
SRCS_MIN+= Target/BPF/BPFSelectionDAGInfo.cpp
SRCS_MIN+= Target/BPF/BPFSubtarget.cpp
SRCS_MIN+= Target/BPF/BPFTargetMachine.cpp
SRCS_MIN+= Target/BPF/BTFDebug.cpp
SRCS_MIN+= Target/BPF/Disassembler/BPFDisassembler.cpp
SRCS_MIN+= Target/BPF/MCTargetDesc/BPFAsmBackend.cpp
SRCS_MIN+= Target/BPF/MCTargetDesc/BPFELFObjectWriter.cpp
SRCS_MIN+= Target/BPF/MCTargetDesc/BPFInstPrinter.cpp
SRCS_MIN+= Target/BPF/MCTargetDesc/BPFMCCodeEmitter.cpp
SRCS_MIN+= Target/BPF/MCTargetDesc/BPFMCTargetDesc.cpp
SRCS_MIN+= Target/BPF/TargetInfo/BPFTargetInfo.cpp
.endif # MK_LLVM_TARGET_BPF
.if ${MK_LLVM_TARGET_MIPS} != "no"
SRCS_MIN+= Target/Mips/AsmParser/MipsAsmParser.cpp
SRCS_XDW+= Target/Mips/Disassembler/MipsDisassembler.cpp
SRCS_MIN+= Target/Mips/MCTargetDesc/MipsABIFlagsSection.cpp
SRCS_MIN+= Target/Mips/MCTargetDesc/MipsABIInfo.cpp
SRCS_MIN+= Target/Mips/MCTargetDesc/MipsAsmBackend.cpp
SRCS_MIN+= Target/Mips/MCTargetDesc/MipsELFObjectWriter.cpp
SRCS_MIN+= Target/Mips/MCTargetDesc/MipsELFStreamer.cpp
SRCS_MIN+= Target/Mips/MCTargetDesc/MipsInstPrinter.cpp
SRCS_MIN+= Target/Mips/MCTargetDesc/MipsMCAsmInfo.cpp
SRCS_MIN+= Target/Mips/MCTargetDesc/MipsMCCodeEmitter.cpp
SRCS_MIN+= Target/Mips/MCTargetDesc/MipsMCExpr.cpp
SRCS_MIN+= Target/Mips/MCTargetDesc/MipsMCTargetDesc.cpp
SRCS_MIN+= Target/Mips/MCTargetDesc/MipsNaClELFStreamer.cpp
SRCS_MIN+= Target/Mips/MCTargetDesc/MipsOptionRecord.cpp
SRCS_MIN+= Target/Mips/MCTargetDesc/MipsTargetStreamer.cpp
SRCS_MIN+= Target/Mips/MicroMipsSizeReduction.cpp
SRCS_MIN+= Target/Mips/Mips16FrameLowering.cpp
SRCS_MIN+= Target/Mips/Mips16HardFloat.cpp
SRCS_MIN+= Target/Mips/Mips16HardFloatInfo.cpp
SRCS_MIN+= Target/Mips/Mips16ISelDAGToDAG.cpp
SRCS_MIN+= Target/Mips/Mips16ISelLowering.cpp
SRCS_MIN+= Target/Mips/Mips16InstrInfo.cpp
SRCS_MIN+= Target/Mips/Mips16RegisterInfo.cpp
SRCS_MIN+= Target/Mips/MipsAnalyzeImmediate.cpp
SRCS_MIN+= Target/Mips/MipsAsmPrinter.cpp
SRCS_MIN+= Target/Mips/MipsBranchExpansion.cpp
SRCS_MIN+= Target/Mips/MipsCCState.cpp
SRCS_MIN+= Target/Mips/MipsCallLowering.cpp
SRCS_MIN+= Target/Mips/MipsConstantIslandPass.cpp
SRCS_MIN+= Target/Mips/MipsDelaySlotFiller.cpp
SRCS_MIN+= Target/Mips/MipsExpandPseudo.cpp
SRCS_MIN+= Target/Mips/MipsFastISel.cpp
SRCS_MIN+= Target/Mips/MipsFrameLowering.cpp
SRCS_MIN+= Target/Mips/MipsISelDAGToDAG.cpp
SRCS_MIN+= Target/Mips/MipsISelLowering.cpp
SRCS_MIN+= Target/Mips/MipsInstrInfo.cpp
SRCS_MIN+= Target/Mips/MipsInstructionSelector.cpp
SRCS_MIN+= Target/Mips/MipsLegalizerInfo.cpp
SRCS_MIN+= Target/Mips/MipsMCInstLower.cpp
SRCS_MIN+= Target/Mips/MipsMachineFunction.cpp
SRCS_MIN+= Target/Mips/MipsModuleISelDAGToDAG.cpp
SRCS_MIN+= Target/Mips/MipsOptimizePICCall.cpp
SRCS_MIN+= Target/Mips/MipsOs16.cpp
SRCS_MIN+= Target/Mips/MipsPreLegalizerCombiner.cpp
SRCS_MIN+= Target/Mips/MipsRegisterBankInfo.cpp
SRCS_MIN+= Target/Mips/MipsRegisterInfo.cpp
SRCS_MIN+= Target/Mips/MipsSEFrameLowering.cpp
SRCS_MIN+= Target/Mips/MipsSEISelDAGToDAG.cpp
SRCS_MIN+= Target/Mips/MipsSEISelLowering.cpp
SRCS_MIN+= Target/Mips/MipsSEInstrInfo.cpp
SRCS_MIN+= Target/Mips/MipsSERegisterInfo.cpp
SRCS_MIN+= Target/Mips/MipsSubtarget.cpp
SRCS_MIN+= Target/Mips/MipsTargetMachine.cpp
SRCS_MIN+= Target/Mips/MipsTargetObjectFile.cpp
SRCS_MIN+= Target/Mips/TargetInfo/MipsTargetInfo.cpp
.endif # MK_LLVM_TARGET_MIPS
.if ${MK_LLVM_TARGET_POWERPC} != "no"
SRCS_MIN+= Target/PowerPC/AsmParser/PPCAsmParser.cpp
SRCS_MIN+= Target/PowerPC/Disassembler/PPCDisassembler.cpp
SRCS_MIN+= Target/PowerPC/GISel/PPCCallLowering.cpp
SRCS_MIN+= Target/PowerPC/GISel/PPCInstructionSelector.cpp
SRCS_MIN+= Target/PowerPC/GISel/PPCLegalizerInfo.cpp
SRCS_MIN+= Target/PowerPC/GISel/PPCRegisterBankInfo.cpp
SRCS_MIN+= Target/PowerPC/MCTargetDesc/PPCAsmBackend.cpp
SRCS_MIN+= Target/PowerPC/MCTargetDesc/PPCELFObjectWriter.cpp
SRCS_MIN+= Target/PowerPC/MCTargetDesc/PPCELFStreamer.cpp
SRCS_MIN+= Target/PowerPC/MCTargetDesc/PPCInstPrinter.cpp
SRCS_MIN+= Target/PowerPC/MCTargetDesc/PPCMCAsmInfo.cpp
SRCS_MIN+= Target/PowerPC/MCTargetDesc/PPCMCCodeEmitter.cpp
SRCS_MIN+= Target/PowerPC/MCTargetDesc/PPCMCExpr.cpp
SRCS_MIN+= Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp
SRCS_MIN+= Target/PowerPC/MCTargetDesc/PPCPredicates.cpp
SRCS_MIN+= Target/PowerPC/MCTargetDesc/PPCXCOFFObjectWriter.cpp
SRCS_MIN+= Target/PowerPC/MCTargetDesc/PPCXCOFFStreamer.cpp
SRCS_MIN+= Target/PowerPC/PPCAsmPrinter.cpp
SRCS_MIN+= Target/PowerPC/PPCBoolRetToInt.cpp
SRCS_MIN+= Target/PowerPC/PPCBranchCoalescing.cpp
SRCS_MIN+= Target/PowerPC/PPCBranchSelector.cpp
SRCS_MIN+= Target/PowerPC/PPCCCState.cpp
SRCS_MIN+= Target/PowerPC/PPCCTRLoops.cpp
SRCS_MIN+= Target/PowerPC/PPCCallingConv.cpp
SRCS_MIN+= Target/PowerPC/PPCEarlyReturn.cpp
SRCS_MIN+= Target/PowerPC/PPCExpandAtomicPseudoInsts.cpp
SRCS_MIN+= Target/PowerPC/PPCExpandISEL.cpp
SRCS_MIN+= Target/PowerPC/PPCFastISel.cpp
SRCS_MIN+= Target/PowerPC/PPCFrameLowering.cpp
SRCS_MIN+= Target/PowerPC/PPCHazardRecognizers.cpp
SRCS_MIN+= Target/PowerPC/PPCISelDAGToDAG.cpp
SRCS_MIN+= Target/PowerPC/PPCISelLowering.cpp
SRCS_MIN+= Target/PowerPC/PPCInstrInfo.cpp
SRCS_MIN+= Target/PowerPC/PPCLoopInstrFormPrep.cpp
SRCS_MIN+= Target/PowerPC/PPCLowerMASSVEntries.cpp
SRCS_MIN+= Target/PowerPC/PPCMacroFusion.cpp
SRCS_MIN+= Target/PowerPC/PPCMCInstLower.cpp
SRCS_MIN+= Target/PowerPC/PPCMIPeephole.cpp
SRCS_MIN+= Target/PowerPC/PPCMachineFunctionInfo.cpp
SRCS_MIN+= Target/PowerPC/PPCMachineScheduler.cpp
SRCS_MIN+= Target/PowerPC/PPCPreEmitPeephole.cpp
SRCS_MIN+= Target/PowerPC/PPCReduceCRLogicals.cpp
SRCS_MIN+= Target/PowerPC/PPCRegisterInfo.cpp
SRCS_MIN+= Target/PowerPC/PPCSubtarget.cpp
SRCS_MIN+= Target/PowerPC/PPCTLSDynamicCall.cpp
SRCS_MIN+= Target/PowerPC/PPCTOCRegDeps.cpp
SRCS_MIN+= Target/PowerPC/PPCTargetMachine.cpp
SRCS_MIN+= Target/PowerPC/PPCTargetObjectFile.cpp
SRCS_MIN+= Target/PowerPC/PPCTargetTransformInfo.cpp
SRCS_MIN+= Target/PowerPC/PPCVSXCopy.cpp
SRCS_MIN+= Target/PowerPC/PPCVSXFMAMutate.cpp
SRCS_MIN+= Target/PowerPC/PPCVSXSwapRemoval.cpp
SRCS_MIN+= Target/PowerPC/TargetInfo/PowerPCTargetInfo.cpp
.endif # MK_LLVM_TARGET_POWERPC
.if ${MK_LLVM_TARGET_RISCV} != "no"
SRCS_MIN+= Target/RISCV/AsmParser/RISCVAsmParser.cpp
SRCS_MIN+= Target/RISCV/Disassembler/RISCVDisassembler.cpp
SRCS_MIN+= Target/RISCV/MCTargetDesc/RISCVAsmBackend.cpp
SRCS_MIN+= Target/RISCV/MCTargetDesc/RISCVBaseInfo.cpp
SRCS_MIN+= Target/RISCV/MCTargetDesc/RISCVELFObjectWriter.cpp
SRCS_MIN+= Target/RISCV/MCTargetDesc/RISCVELFStreamer.cpp
SRCS_MIN+= Target/RISCV/MCTargetDesc/RISCVInstPrinter.cpp
SRCS_MIN+= Target/RISCV/MCTargetDesc/RISCVMatInt.cpp
SRCS_MIN+= Target/RISCV/MCTargetDesc/RISCVMCAsmInfo.cpp
SRCS_MIN+= Target/RISCV/MCTargetDesc/RISCVMCCodeEmitter.cpp
SRCS_MIN+= Target/RISCV/MCTargetDesc/RISCVMCExpr.cpp
SRCS_MIN+= Target/RISCV/MCTargetDesc/RISCVMCObjectFileInfo.cpp
SRCS_MIN+= Target/RISCV/MCTargetDesc/RISCVMCTargetDesc.cpp
SRCS_MIN+= Target/RISCV/MCTargetDesc/RISCVTargetStreamer.cpp
SRCS_MIN+= Target/RISCV/RISCVAsmPrinter.cpp
SRCS_MIN+= Target/RISCV/RISCVCallLowering.cpp
SRCS_MIN+= Target/RISCV/RISCVExpandAtomicPseudoInsts.cpp
SRCS_MIN+= Target/RISCV/RISCVExpandPseudoInsts.cpp
SRCS_MIN+= Target/RISCV/RISCVFrameLowering.cpp
SRCS_MIN+= Target/RISCV/RISCVGatherScatterLowering.cpp
SRCS_MIN+= Target/RISCV/RISCVInsertVSETVLI.cpp
SRCS_MIN+= Target/RISCV/RISCVInstrInfo.cpp
SRCS_MIN+= Target/RISCV/RISCVInstructionSelector.cpp
SRCS_MIN+= Target/RISCV/RISCVISelDAGToDAG.cpp
SRCS_MIN+= Target/RISCV/RISCVISelLowering.cpp
SRCS_MIN+= Target/RISCV/RISCVLegalizerInfo.cpp
SRCS_MIN+= Target/RISCV/RISCVMCInstLower.cpp
SRCS_MIN+= Target/RISCV/RISCVMergeBaseOffset.cpp
SRCS_MIN+= Target/RISCV/RISCVRegisterBankInfo.cpp
SRCS_MIN+= Target/RISCV/RISCVRegisterInfo.cpp
SRCS_MIN+= Target/RISCV/RISCVSExtWRemoval.cpp
SRCS_MIN+= Target/RISCV/RISCVSubtarget.cpp
SRCS_MIN+= Target/RISCV/RISCVTargetMachine.cpp
SRCS_MIN+= Target/RISCV/RISCVTargetObjectFile.cpp
SRCS_MIN+= Target/RISCV/RISCVTargetTransformInfo.cpp
SRCS_MIN+= Target/RISCV/TargetInfo/RISCVTargetInfo.cpp
.endif # MK_LLVM_TARGET_RISCV
SRCS_MIN+= Target/Target.cpp
SRCS_MIN+= Target/TargetLoweringObjectFile.cpp
SRCS_MIN+= Target/TargetMachine.cpp
SRCS_MIN+= Target/TargetMachineC.cpp
.if ${MK_LLVM_TARGET_X86} != "no"
SRCS_MIN+= Target/X86/AsmParser/X86AsmParser.cpp
SRCS_XDW+= Target/X86/Disassembler/X86Disassembler.cpp
SRCS_MIN+= Target/X86/MCTargetDesc/X86ATTInstPrinter.cpp
SRCS_MIN+= Target/X86/MCTargetDesc/X86AsmBackend.cpp
SRCS_MIN+= Target/X86/MCTargetDesc/X86ELFObjectWriter.cpp
SRCS_MIN+= Target/X86/MCTargetDesc/X86InstComments.cpp
SRCS_MIN+= Target/X86/MCTargetDesc/X86InstPrinterCommon.cpp
SRCS_MIN+= Target/X86/MCTargetDesc/X86IntelInstPrinter.cpp
SRCS_MIN+= Target/X86/MCTargetDesc/X86MCAsmInfo.cpp
SRCS_MIN+= Target/X86/MCTargetDesc/X86MCCodeEmitter.cpp
SRCS_MIN+= Target/X86/MCTargetDesc/X86MCTargetDesc.cpp
SRCS_MIN+= Target/X86/MCTargetDesc/X86MachObjectWriter.cpp
SRCS_MIN+= Target/X86/MCTargetDesc/X86ShuffleDecode.cpp
SRCS_MIN+= Target/X86/MCTargetDesc/X86WinCOFFObjectWriter.cpp
SRCS_MIN+= Target/X86/MCTargetDesc/X86WinCOFFStreamer.cpp
SRCS_MIN+= Target/X86/MCTargetDesc/X86WinCOFFTargetStreamer.cpp
SRCS_MIN+= Target/X86/TargetInfo/X86TargetInfo.cpp
SRCS_MIN+= Target/X86/X86AsmPrinter.cpp
SRCS_MIN+= Target/X86/X86AvoidStoreForwardingBlocks.cpp
SRCS_MIN+= Target/X86/X86AvoidTrailingCall.cpp
SRCS_MIN+= Target/X86/X86CallFrameOptimization.cpp
SRCS_MIN+= Target/X86/X86CallLowering.cpp
SRCS_MIN+= Target/X86/X86CallingConv.cpp
SRCS_MIN+= Target/X86/X86CmovConversion.cpp
SRCS_MIN+= Target/X86/X86DiscriminateMemOps.cpp
SRCS_MIN+= Target/X86/X86DomainReassignment.cpp
SRCS_MIN+= Target/X86/X86DynAllocaExpander.cpp
SRCS_MIN+= Target/X86/X86EvexToVex.cpp
SRCS_MIN+= Target/X86/X86ExpandPseudo.cpp
SRCS_MIN+= Target/X86/X86FastISel.cpp
SRCS_MIN+= Target/X86/X86FastTileConfig.cpp
SRCS_MIN+= Target/X86/X86FixupBWInsts.cpp
SRCS_MIN+= Target/X86/X86FixupLEAs.cpp
SRCS_MIN+= Target/X86/X86FixupSetCC.cpp
SRCS_MIN+= Target/X86/X86FlagsCopyLowering.cpp
SRCS_MIN+= Target/X86/X86FloatingPoint.cpp
SRCS_MIN+= Target/X86/X86FrameLowering.cpp
SRCS_MIN+= Target/X86/X86ISelDAGToDAG.cpp
SRCS_MIN+= Target/X86/X86ISelLowering.cpp
SRCS_MIN+= Target/X86/X86IndirectBranchTracking.cpp
SRCS_MIN+= Target/X86/X86IndirectThunks.cpp
SRCS_MIN+= Target/X86/X86InsertPrefetch.cpp
SRCS_MIN+= Target/X86/X86InsertWait.cpp
SRCS_MIN+= Target/X86/X86InstCombineIntrinsic.cpp
SRCS_MIN+= Target/X86/X86InstrFMA3Info.cpp
SRCS_MIN+= Target/X86/X86InstrFoldTables.cpp
SRCS_MIN+= Target/X86/X86InstrInfo.cpp
SRCS_MIN+= Target/X86/X86InstructionSelector.cpp
SRCS_MIN+= Target/X86/X86InterleavedAccess.cpp
SRCS_MIN+= Target/X86/X86LegalizerInfo.cpp
SRCS_MIN+= Target/X86/X86LoadValueInjectionLoadHardening.cpp
SRCS_MIN+= Target/X86/X86LoadValueInjectionRetHardening.cpp
SRCS_MIN+= Target/X86/X86LowerAMXIntrinsics.cpp
SRCS_MIN+= Target/X86/X86LowerAMXType.cpp
SRCS_MIN+= Target/X86/X86LowerTileCopy.cpp
SRCS_MIN+= Target/X86/X86MCInstLower.cpp
SRCS_MIN+= Target/X86/X86MachineFunctionInfo.cpp
SRCS_MIN+= Target/X86/X86MacroFusion.cpp
SRCS_MIN+= Target/X86/X86OptimizeLEAs.cpp
SRCS_MIN+= Target/X86/X86PadShortFunction.cpp
SRCS_MIN+= Target/X86/X86PartialReduction.cpp
SRCS_MIN+= Target/X86/X86PreAMXConfig.cpp
SRCS_MIN+= Target/X86/X86PreTileConfig.cpp
SRCS_MIN+= Target/X86/X86RegisterBankInfo.cpp
SRCS_MIN+= Target/X86/X86RegisterInfo.cpp
SRCS_MIN+= Target/X86/X86SelectionDAGInfo.cpp
SRCS_MIN+= Target/X86/X86ShuffleDecodeConstantPool.cpp
SRCS_MIN+= Target/X86/X86SpeculativeExecutionSideEffectSuppression.cpp
SRCS_MIN+= Target/X86/X86SpeculativeLoadHardening.cpp
SRCS_MIN+= Target/X86/X86Subtarget.cpp
SRCS_MIN+= Target/X86/X86TargetMachine.cpp
SRCS_MIN+= Target/X86/X86TargetObjectFile.cpp
SRCS_MIN+= Target/X86/X86TargetTransformInfo.cpp
SRCS_MIN+= Target/X86/X86TileConfig.cpp
SRCS_MIN+= Target/X86/X86VZeroUpper.cpp
SRCS_MIN+= Target/X86/X86WinEHState.cpp
.endif # MK_LLVM_TARGET_X86
SRCS_MIW+= TextAPI/Architecture.cpp
SRCS_MIW+= TextAPI/ArchitectureSet.cpp
SRCS_MIW+= TextAPI/InterfaceFile.cpp
SRCS_MIW+= TextAPI/PackedVersion.cpp
SRCS_MIW+= TextAPI/Platform.cpp
SRCS_MIW+= TextAPI/Target.cpp
SRCS_MIW+= TextAPI/TextStub.cpp
SRCS_MIW+= TextAPI/TextStubCommon.cpp
SRCS_MIN+= ToolDrivers/llvm-dlltool/DlltoolDriver.cpp
SRCS_MIW+= ToolDrivers/llvm-lib/LibDriver.cpp
SRCS_MIN+= Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp
SRCS_MIN+= Transforms/AggressiveInstCombine/TruncInstCombine.cpp
SRCS_MIN+= Transforms/CFGuard/CFGuard.cpp
SRCS_MIN+= Transforms/Coroutines/CoroCleanup.cpp
SRCS_MIN+= Transforms/Coroutines/CoroEarly.cpp
SRCS_MIN+= Transforms/Coroutines/CoroElide.cpp
SRCS_MIN+= Transforms/Coroutines/CoroFrame.cpp
SRCS_MIN+= Transforms/Coroutines/CoroSplit.cpp
SRCS_MIN+= Transforms/Coroutines/Coroutines.cpp
SRCS_MIN+= Transforms/IPO/AlwaysInliner.cpp
SRCS_MIN+= Transforms/IPO/Annotation2Metadata.cpp
SRCS_MIN+= Transforms/IPO/ArgumentPromotion.cpp
SRCS_MIN+= Transforms/IPO/Attributor.cpp
SRCS_MIN+= Transforms/IPO/AttributorAttributes.cpp
SRCS_MIN+= Transforms/IPO/BarrierNoopPass.cpp
SRCS_MIN+= Transforms/IPO/BlockExtractor.cpp
SRCS_MIN+= Transforms/IPO/CalledValuePropagation.cpp
SRCS_MIN+= Transforms/IPO/ConstantMerge.cpp
SRCS_MIN+= Transforms/IPO/CrossDSOCFI.cpp
SRCS_MIN+= Transforms/IPO/DeadArgumentElimination.cpp
SRCS_MIN+= Transforms/IPO/ElimAvailExtern.cpp
SRCS_MIN+= Transforms/IPO/ExtractGV.cpp
SRCS_MIN+= Transforms/IPO/ForceFunctionAttrs.cpp
SRCS_MIN+= Transforms/IPO/FunctionAttrs.cpp
SRCS_MIN+= Transforms/IPO/FunctionImport.cpp
SRCS_MIN+= Transforms/IPO/FunctionSpecialization.cpp
SRCS_MIN+= Transforms/IPO/GlobalDCE.cpp
SRCS_MIN+= Transforms/IPO/GlobalOpt.cpp
SRCS_MIN+= Transforms/IPO/GlobalSplit.cpp
SRCS_MIN+= Transforms/IPO/HotColdSplitting.cpp
SRCS_EXT+= Transforms/IPO/IPO.cpp
SRCS_MIN+= Transforms/IPO/IROutliner.cpp
SRCS_MIN+= Transforms/IPO/InferFunctionAttrs.cpp
SRCS_MIN+= Transforms/IPO/InlineSimple.cpp
SRCS_MIN+= Transforms/IPO/Inliner.cpp
SRCS_MIN+= Transforms/IPO/Internalize.cpp
SRCS_MIN+= Transforms/IPO/LoopExtractor.cpp
SRCS_MIN+= Transforms/IPO/LowerTypeTests.cpp
SRCS_MIN+= Transforms/IPO/MergeFunctions.cpp
SRCS_MIN+= Transforms/IPO/ModuleInliner.cpp
SRCS_MIN+= Transforms/IPO/OpenMPOpt.cpp
SRCS_MIN+= Transforms/IPO/PartialInlining.cpp
SRCS_MIN+= Transforms/IPO/PassManagerBuilder.cpp
SRCS_MIN+= Transforms/IPO/PruneEH.cpp
SRCS_MIN+= Transforms/IPO/SCCP.cpp
SRCS_MIN+= Transforms/IPO/SampleContextTracker.cpp
SRCS_MIN+= Transforms/IPO/SampleProfile.cpp
SRCS_MIN+= Transforms/IPO/SampleProfileProbe.cpp
SRCS_MIN+= Transforms/IPO/StripDeadPrototypes.cpp
SRCS_MIN+= Transforms/IPO/StripSymbols.cpp
SRCS_MIN+= Transforms/IPO/SyntheticCountsPropagation.cpp
SRCS_MIN+= Transforms/IPO/ThinLTOBitcodeWriter.cpp
SRCS_MIN+= Transforms/IPO/WholeProgramDevirt.cpp
SRCS_MIN+= Transforms/InstCombine/InstCombineAddSub.cpp
SRCS_MIN+= Transforms/InstCombine/InstCombineAndOrXor.cpp
SRCS_MIN+= Transforms/InstCombine/InstCombineAtomicRMW.cpp
SRCS_MIN+= Transforms/InstCombine/InstCombineCalls.cpp
SRCS_MIN+= Transforms/InstCombine/InstCombineCasts.cpp
SRCS_MIN+= Transforms/InstCombine/InstCombineCompares.cpp
SRCS_MIN+= Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
SRCS_MIN+= Transforms/InstCombine/InstCombineMulDivRem.cpp
SRCS_MIN+= Transforms/InstCombine/InstCombineNegator.cpp
SRCS_MIN+= Transforms/InstCombine/InstCombinePHI.cpp
SRCS_MIN+= Transforms/InstCombine/InstCombineSelect.cpp
SRCS_MIN+= Transforms/InstCombine/InstCombineShifts.cpp
SRCS_MIN+= Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
SRCS_MIN+= Transforms/InstCombine/InstCombineVectorOps.cpp
SRCS_MIN+= Transforms/InstCombine/InstructionCombining.cpp
SRCS_MIN+= Transforms/Instrumentation/AddressSanitizer.cpp
SRCS_MIN+= Transforms/Instrumentation/BoundsChecking.cpp
SRCS_MIN+= Transforms/Instrumentation/CGProfile.cpp
SRCS_MIN+= Transforms/Instrumentation/ControlHeightReduction.cpp
SRCS_MIN+= Transforms/Instrumentation/DataFlowSanitizer.cpp
SRCS_MIN+= Transforms/Instrumentation/GCOVProfiling.cpp
SRCS_MIN+= Transforms/Instrumentation/HWAddressSanitizer.cpp
SRCS_MIN+= Transforms/Instrumentation/IndirectCallPromotion.cpp
SRCS_MIN+= Transforms/Instrumentation/InstrOrderFile.cpp
SRCS_MIN+= Transforms/Instrumentation/InstrProfiling.cpp
SRCS_MIN+= Transforms/Instrumentation/Instrumentation.cpp
SRCS_MIN+= Transforms/Instrumentation/MemProfiler.cpp
SRCS_MIN+= Transforms/Instrumentation/MemorySanitizer.cpp
SRCS_MIN+= Transforms/Instrumentation/PGOInstrumentation.cpp
SRCS_MIN+= Transforms/Instrumentation/PGOMemOPSizeOpt.cpp
SRCS_MIN+= Transforms/Instrumentation/PoisonChecking.cpp
SRCS_MIN+= Transforms/Instrumentation/SanitizerCoverage.cpp
SRCS_MIN+= Transforms/Instrumentation/ThreadSanitizer.cpp
SRCS_MIN+= Transforms/Instrumentation/ValueProfileCollector.cpp
SRCS_MIN+= Transforms/ObjCARC/DependencyAnalysis.cpp
SRCS_MIN+= Transforms/ObjCARC/ObjCARC.cpp
SRCS_MIN+= Transforms/ObjCARC/ObjCARCAPElim.cpp
SRCS_MIN+= Transforms/ObjCARC/ObjCARCContract.cpp
SRCS_MIN+= Transforms/ObjCARC/ObjCARCExpand.cpp
SRCS_MIN+= Transforms/ObjCARC/ObjCARCOpts.cpp
SRCS_MIN+= Transforms/ObjCARC/ProvenanceAnalysis.cpp
SRCS_MIN+= Transforms/ObjCARC/ProvenanceAnalysisEvaluator.cpp
SRCS_MIN+= Transforms/ObjCARC/PtrState.cpp
SRCS_MIN+= Transforms/Scalar/ADCE.cpp
SRCS_MIN+= Transforms/Scalar/AlignmentFromAssumptions.cpp
SRCS_MIN+= Transforms/Scalar/AnnotationRemarks.cpp
SRCS_MIN+= Transforms/Scalar/BDCE.cpp
SRCS_MIN+= Transforms/Scalar/CallSiteSplitting.cpp
SRCS_MIN+= Transforms/Scalar/ConstantHoisting.cpp
SRCS_MIN+= Transforms/Scalar/ConstraintElimination.cpp
SRCS_MIN+= Transforms/Scalar/CorrelatedValuePropagation.cpp
SRCS_MIN+= Transforms/Scalar/DCE.cpp
SRCS_MIN+= Transforms/Scalar/DFAJumpThreading.cpp
SRCS_MIN+= Transforms/Scalar/DeadStoreElimination.cpp
SRCS_MIN+= Transforms/Scalar/DivRemPairs.cpp
SRCS_MIN+= Transforms/Scalar/EarlyCSE.cpp
SRCS_MIN+= Transforms/Scalar/FlattenCFGPass.cpp
SRCS_MIN+= Transforms/Scalar/Float2Int.cpp
SRCS_MIN+= Transforms/Scalar/GVN.cpp
SRCS_MIN+= Transforms/Scalar/GVNHoist.cpp
SRCS_MIN+= Transforms/Scalar/GVNSink.cpp
SRCS_MIN+= Transforms/Scalar/GuardWidening.cpp
SRCS_MIN+= Transforms/Scalar/IVUsersPrinter.cpp
SRCS_MIN+= Transforms/Scalar/IndVarSimplify.cpp
SRCS_MIN+= Transforms/Scalar/InductiveRangeCheckElimination.cpp
SRCS_MIN+= Transforms/Scalar/InferAddressSpaces.cpp
SRCS_MIN+= Transforms/Scalar/InstSimplifyPass.cpp
SRCS_MIN+= Transforms/Scalar/JumpThreading.cpp
SRCS_MIN+= Transforms/Scalar/LICM.cpp
SRCS_MIN+= Transforms/Scalar/LoopAccessAnalysisPrinter.cpp
SRCS_MIN+= Transforms/Scalar/LoopBoundSplit.cpp
SRCS_MIN+= Transforms/Scalar/LoopDataPrefetch.cpp
SRCS_MIN+= Transforms/Scalar/LoopDeletion.cpp
SRCS_MIN+= Transforms/Scalar/LoopDistribute.cpp
SRCS_MIN+= Transforms/Scalar/LoopFlatten.cpp
SRCS_MIN+= Transforms/Scalar/LoopFuse.cpp
SRCS_MIN+= Transforms/Scalar/LoopIdiomRecognize.cpp
SRCS_MIN+= Transforms/Scalar/LoopInstSimplify.cpp
SRCS_MIN+= Transforms/Scalar/LoopInterchange.cpp
SRCS_MIN+= Transforms/Scalar/LoopLoadElimination.cpp
SRCS_MIN+= Transforms/Scalar/LoopPassManager.cpp
SRCS_MIN+= Transforms/Scalar/LoopPredication.cpp
SRCS_MIN+= Transforms/Scalar/LoopRerollPass.cpp
SRCS_MIN+= Transforms/Scalar/LoopRotation.cpp
SRCS_MIN+= Transforms/Scalar/LoopSimplifyCFG.cpp
SRCS_MIN+= Transforms/Scalar/LoopSink.cpp
SRCS_MIN+= Transforms/Scalar/LoopStrengthReduce.cpp
SRCS_MIN+= Transforms/Scalar/LoopUnrollPass.cpp
SRCS_MIN+= Transforms/Scalar/LoopUnrollAndJamPass.cpp
SRCS_MIN+= Transforms/Scalar/LoopUnswitch.cpp
SRCS_MIN+= Transforms/Scalar/LoopVersioningLICM.cpp
SRCS_MIN+= Transforms/Scalar/LowerAtomic.cpp
SRCS_MIN+= Transforms/Scalar/LowerConstantIntrinsics.cpp
SRCS_MIN+= Transforms/Scalar/LowerExpectIntrinsic.cpp
SRCS_MIN+= Transforms/Scalar/LowerGuardIntrinsic.cpp
SRCS_MIN+= Transforms/Scalar/LowerMatrixIntrinsics.cpp
SRCS_MIN+= Transforms/Scalar/LowerWidenableCondition.cpp
SRCS_MIN+= Transforms/Scalar/MakeGuardsExplicit.cpp
SRCS_MIN+= Transforms/Scalar/MemCpyOptimizer.cpp
SRCS_MIN+= Transforms/Scalar/MergeICmps.cpp
SRCS_MIN+= Transforms/Scalar/MergedLoadStoreMotion.cpp
SRCS_MIN+= Transforms/Scalar/NaryReassociate.cpp
SRCS_MIN+= Transforms/Scalar/NewGVN.cpp
SRCS_MIN+= Transforms/Scalar/PartiallyInlineLibCalls.cpp
SRCS_MIN+= Transforms/Scalar/PlaceSafepoints.cpp
SRCS_MIN+= Transforms/Scalar/Reassociate.cpp
SRCS_MIN+= Transforms/Scalar/Reg2Mem.cpp
SRCS_MIN+= Transforms/Scalar/RewriteStatepointsForGC.cpp
SRCS_MIN+= Transforms/Scalar/SCCP.cpp
SRCS_MIN+= Transforms/Scalar/SROA.cpp
SRCS_EXT+= Transforms/Scalar/Scalar.cpp
SRCS_MIN+= Transforms/Scalar/ScalarizeMaskedMemIntrin.cpp
SRCS_MIN+= Transforms/Scalar/Scalarizer.cpp
SRCS_MIN+= Transforms/Scalar/SeparateConstOffsetFromGEP.cpp
SRCS_MIN+= Transforms/Scalar/SimpleLoopUnswitch.cpp
SRCS_MIN+= Transforms/Scalar/SimplifyCFGPass.cpp
SRCS_MIN+= Transforms/Scalar/Sink.cpp
SRCS_MIN+= Transforms/Scalar/SpeculativeExecution.cpp
SRCS_MIN+= Transforms/Scalar/StraightLineStrengthReduce.cpp
SRCS_MIN+= Transforms/Scalar/StructurizeCFG.cpp
SRCS_MIN+= Transforms/Scalar/TailRecursionElimination.cpp
SRCS_MIN+= Transforms/Scalar/WarnMissedTransforms.cpp
SRCS_MIN+= Transforms/Utils/AMDGPUEmitPrintf.cpp
SRCS_MIN+= Transforms/Utils/ASanStackFrameLayout.cpp
SRCS_MIN+= Transforms/Utils/AddDiscriminators.cpp
SRCS_MIN+= Transforms/Utils/AssumeBundleBuilder.cpp
SRCS_MIN+= Transforms/Utils/BasicBlockUtils.cpp
SRCS_MIN+= Transforms/Utils/BreakCriticalEdges.cpp
SRCS_MIN+= Transforms/Utils/BuildLibCalls.cpp
SRCS_MIN+= Transforms/Utils/BypassSlowDivision.cpp
SRCS_MIN+= Transforms/Utils/CallGraphUpdater.cpp
SRCS_MIN+= Transforms/Utils/CallPromotionUtils.cpp
SRCS_MIN+= Transforms/Utils/CanonicalizeAliases.cpp
SRCS_MIN+= Transforms/Utils/CanonicalizeFreezeInLoops.cpp
SRCS_MIN+= Transforms/Utils/CloneFunction.cpp
SRCS_MIN+= Transforms/Utils/CloneModule.cpp
SRCS_MIN+= Transforms/Utils/CodeExtractor.cpp
SRCS_MIN+= Transforms/Utils/CodeLayout.cpp
SRCS_MIN+= Transforms/Utils/CodeMoverUtils.cpp
SRCS_MIN+= Transforms/Utils/CtorUtils.cpp
SRCS_MIN+= Transforms/Utils/Debugify.cpp
SRCS_MIN+= Transforms/Utils/DemoteRegToStack.cpp
SRCS_MIN+= Transforms/Utils/EntryExitInstrumenter.cpp
SRCS_MIN+= Transforms/Utils/EscapeEnumerator.cpp
SRCS_MIN+= Transforms/Utils/Evaluator.cpp
SRCS_MIN+= Transforms/Utils/FixIrreducible.cpp
SRCS_MIN+= Transforms/Utils/FlattenCFG.cpp
SRCS_MIN+= Transforms/Utils/FunctionComparator.cpp
SRCS_MIN+= Transforms/Utils/FunctionImportUtils.cpp
SRCS_MIN+= Transforms/Utils/GlobalStatus.cpp
SRCS_MIN+= Transforms/Utils/GuardUtils.cpp
SRCS_MIN+= Transforms/Utils/HelloWorld.cpp
SRCS_MIN+= Transforms/Utils/InjectTLIMappings.cpp
SRCS_MIN+= Transforms/Utils/InlineFunction.cpp
SRCS_MIN+= Transforms/Utils/InstructionNamer.cpp
SRCS_MIN+= Transforms/Utils/IntegerDivision.cpp
SRCS_MIN+= Transforms/Utils/LCSSA.cpp
SRCS_MIN+= Transforms/Utils/LibCallsShrinkWrap.cpp
SRCS_MIN+= Transforms/Utils/Local.cpp
SRCS_MIN+= Transforms/Utils/LoopPeel.cpp
SRCS_MIN+= Transforms/Utils/LoopSimplify.cpp
SRCS_MIN+= Transforms/Utils/LoopRotationUtils.cpp
SRCS_MIN+= Transforms/Utils/LoopUnroll.cpp
SRCS_MIN+= Transforms/Utils/LoopUnrollAndJam.cpp
SRCS_MIN+= Transforms/Utils/LoopUnrollRuntime.cpp
SRCS_MIN+= Transforms/Utils/LoopUtils.cpp
SRCS_MIN+= Transforms/Utils/LoopVersioning.cpp
SRCS_MIN+= Transforms/Utils/LowerInvoke.cpp
SRCS_MIN+= Transforms/Utils/LowerSwitch.cpp
SRCS_MIN+= Transforms/Utils/MatrixUtils.cpp
SRCS_MIN+= Transforms/Utils/Mem2Reg.cpp
SRCS_MIN+= Transforms/Utils/MetaRenamer.cpp
SRCS_MIN+= Transforms/Utils/MemoryOpRemark.cpp
SRCS_MIN+= Transforms/Utils/ModuleUtils.cpp
SRCS_MIN+= Transforms/Utils/NameAnonGlobals.cpp
SRCS_MIN+= Transforms/Utils/PredicateInfo.cpp
SRCS_MIN+= Transforms/Utils/PromoteMemoryToRegister.cpp
SRCS_MIN+= Transforms/Utils/RelLookupTableConverter.cpp
SRCS_MIN+= Transforms/Utils/SCCPSolver.cpp
SRCS_MIN+= Transforms/Utils/SSAUpdater.cpp
SRCS_MIN+= Transforms/Utils/SSAUpdaterBulk.cpp
SRCS_MIN+= Transforms/Utils/SanitizerStats.cpp
SRCS_MIN+= Transforms/Utils/ScalarEvolutionExpander.cpp
SRCS_MIN+= Transforms/Utils/SampleProfileInference.cpp
SRCS_MIN+= Transforms/Utils/SampleProfileLoaderBaseUtil.cpp
SRCS_MIN+= Transforms/Utils/SimplifyCFG.cpp
SRCS_MIN+= Transforms/Utils/SimplifyIndVar.cpp
SRCS_MIN+= Transforms/Utils/SimplifyLibCalls.cpp
SRCS_MIN+= Transforms/Utils/SizeOpts.cpp
SRCS_MIN+= Transforms/Utils/SplitModule.cpp
SRCS_MIN+= Transforms/Utils/StripGCRelocates.cpp
SRCS_MIN+= Transforms/Utils/StripNonLineTableDebugInfo.cpp
SRCS_MIN+= Transforms/Utils/SymbolRewriter.cpp
SRCS_MIN+= Transforms/Utils/UnifyFunctionExitNodes.cpp
SRCS_MIN+= Transforms/Utils/UnifyLoopExits.cpp
SRCS_EXT+= Transforms/Utils/Utils.cpp
SRCS_MIN+= Transforms/Utils/VNCoercion.cpp
SRCS_MIN+= Transforms/Utils/ValueMapper.cpp
SRCS_MIN+= Transforms/Vectorize/LoadStoreVectorizer.cpp
SRCS_MIN+= Transforms/Vectorize/LoopVectorizationLegality.cpp
SRCS_MIN+= Transforms/Vectorize/LoopVectorize.cpp
SRCS_MIN+= Transforms/Vectorize/SLPVectorizer.cpp
SRCS_MIN+= Transforms/Vectorize/VPlan.cpp
SRCS_MIN+= Transforms/Vectorize/VPlanHCFGBuilder.cpp
SRCS_MIN+= Transforms/Vectorize/VPlanPredicator.cpp
SRCS_MIN+= Transforms/Vectorize/VPlanTransforms.cpp
SRCS_MIN+= Transforms/Vectorize/VPlanVerifier.cpp
SRCS_MIN+= Transforms/Vectorize/VectorCombine.cpp
SRCS_EXT+= Transforms/Vectorize/Vectorize.cpp
SRCS_EXT+= XRay/BlockIndexer.cpp
SRCS_EXT+= XRay/BlockVerifier.cpp
SRCS_EXT+= XRay/FDRRecordProducer.cpp
SRCS_EXT+= XRay/FDRRecords.cpp
SRCS_EXT+= XRay/FDRTraceExpander.cpp
SRCS_EXT+= XRay/FileHeaderReader.cpp
SRCS_EXT+= XRay/InstrumentationMap.cpp
SRCS_EXT+= XRay/LogBuilderConsumer.cpp
SRCS_EXT+= XRay/RecordInitializer.cpp
SRCS_EXT+= XRay/Trace.cpp
SRCS_ALL+= ${SRCS_MIN}
.if !defined(TOOLS_PREFIX) || ${MK_LLD_BOOTSTRAP} != "no"
SRCS_ALL+= ${SRCS_MIW}
.endif
.if ${MK_CLANG_EXTRAS} != "no"
SRCS_ALL+= ${SRCS_EXT}
.endif
.if ${MK_CLANG_FULL} != "no"
SRCS_ALL+= ${SRCS_FUL}
.endif
.if ${MK_CLANG_EXTRAS} != "no" || ${MK_LLD} != "no" || \
(defined(TOOLS_PREFIX) && ${MK_LLD_BOOTSTRAP} != "no")
SRCS_ALL+= ${SRCS_EXL}
.endif
.if ${MK_LLD} != "no" || \
(defined(TOOLS_PREFIX) && ${MK_LLD_BOOTSTRAP} != "no")
SRCS_ALL+= ${SRCS_LLD}
.endif
.if ${MK_CLANG_EXTRAS} != "no" || ${MK_LLDB} != "no"
SRCS_ALL+= ${SRCS_XDB}
.endif
.if ${MK_CLANG_EXTRAS} != "no" || ${MK_LLDB} != "no" || ${MK_LLD} != "no" || \
(defined(TOOLS_PREFIX) && ${MK_LLD_BOOTSTRAP} != "no")
SRCS_ALL+= ${SRCS_XDL}
.endif
.if ${MK_CLANG_EXTRAS} != "no" || ${MK_LLDB} != "no" || !defined(TOOLS_PREFIX)
SRCS_ALL+= ${SRCS_XDW}
.endif
SRCS+= ${GENSRCS}
SRCS+= ${SRCS_ALL:O}
llvm/Frontend/OpenMP/OMP.h.inc: ${LLVM_SRCS}/include/llvm/Frontend/OpenMP/OMP.td
${LLVM_TBLGEN} --gen-directive-decl \
-I ${LLVM_SRCS}/include -d ${.TARGET}.d -o ${.TARGET} \
${LLVM_SRCS}/include/llvm/Frontend/OpenMP/OMP.td
TGHDRS+= llvm/Frontend/OpenMP/OMP.h.inc
llvm/Frontend/OpenMP/OMP.inc: ${LLVM_SRCS}/include/llvm/Frontend/OpenMP/OMP.td
${LLVM_TBLGEN} --gen-directive-impl \
-I ${LLVM_SRCS}/include -d ${.TARGET}.d -o ${.TARGET} \
${LLVM_SRCS}/include/llvm/Frontend/OpenMP/OMP.td
TGHDRS+= llvm/Frontend/OpenMP/OMP.inc
OMP.cpp: ${LLVM_SRCS}/include/llvm/Frontend/OpenMP/OMP.td
${LLVM_TBLGEN} --gen-directive-impl \
-I ${LLVM_SRCS}/include -d ${.TARGET}.d -o ${.TARGET} \
${LLVM_SRCS}/include/llvm/Frontend/OpenMP/OMP.td
GENSRCS+= OMP.cpp
llvm/IR/Attributes.inc: ${LLVM_SRCS}/include/llvm/IR/Attributes.td
${LLVM_TBLGEN} -gen-attrs \
-I ${LLVM_SRCS}/include -d ${.TARGET}.d -o ${.TARGET} \
${LLVM_SRCS}/include/llvm/IR/Attributes.td
TGHDRS+= llvm/IR/Attributes.inc
llvm/IR/IntrinsicEnums.inc: ${LLVM_SRCS}/include/llvm/IR/Intrinsics.td
${LLVM_TBLGEN} -gen-intrinsic-enums \
-I ${LLVM_SRCS}/include -d ${.TARGET}.d -o ${.TARGET} \
${LLVM_SRCS}/include/llvm/IR/Intrinsics.td
TGHDRS+= llvm/IR/IntrinsicEnums.inc
llvm/IR/IntrinsicImpl.inc: ${LLVM_SRCS}/include/llvm/IR/Intrinsics.td
${LLVM_TBLGEN} -gen-intrinsic-impl \
-I ${LLVM_SRCS}/include -d ${.TARGET}.d -o ${.TARGET} \
${LLVM_SRCS}/include/llvm/IR/Intrinsics.td
TGHDRS+= llvm/IR/IntrinsicImpl.inc
.for arch in \
AArch64/aarch64 AMDGPU/amdgcn ARM/arm BPF/bpf Hexagon/hexagon \
Mips/mips NVPTX/nvvm PowerPC/ppc R600/r600 RISCV/riscv S390/s390 \
VE/ve WebAssembly/wasm X86/x86 XCore/xcore
llvm/IR/Intrinsics${arch:H}.h: ${LLVM_SRCS}/include/llvm/IR/Intrinsics.td
${LLVM_TBLGEN} -gen-intrinsic-enums -intrinsic-prefix=${arch:T} \
-I ${LLVM_SRCS}/include -d ${.TARGET}.d -o ${.TARGET} \
${LLVM_SRCS}/include/llvm/IR/Intrinsics.td
TGHDRS+= llvm/IR/Intrinsics${arch:H}.h
.endfor
llvm-lib/Options.inc: ${LLVM_SRCS}/lib/ToolDrivers/llvm-lib/Options.td
${LLVM_TBLGEN} -gen-opt-parser-defs \
-I ${LLVM_SRCS}/include -d ${.TARGET}.d -o ${.TARGET} \
${LLVM_SRCS}/lib/ToolDrivers/llvm-lib/Options.td
TGHDRS+= llvm-lib/Options.inc
CFLAGS.LibDriver.cpp+= -I${.OBJDIR}/llvm-lib
llvm-dlltool/Options.inc: ${LLVM_SRCS}/lib/ToolDrivers/llvm-dlltool/Options.td
${LLVM_TBLGEN} -gen-opt-parser-defs \
-I ${LLVM_SRCS}/include -d ${.TARGET}.d -o ${.TARGET} \
${LLVM_SRCS}/lib/ToolDrivers/llvm-dlltool/Options.td
TGHDRS+= llvm-dlltool/Options.inc
CFLAGS.DlltoolDriver.cpp+= -I${.OBJDIR}/llvm-dlltool
beforebuild:
# 20170724 remove stale Options.inc file, of which there are two different
# versions after upstream r308421, one for llvm-lib, one for llvm-dlltool
.for f in Options.inc
.if exists(${f}) || exists(${f}.d)
@echo Removing stale generated ${f} files
@rm -f ${f} ${f}.d
.endif
.endfor
# Note: some rules are superfluous, not every combination is valid.
.for arch in \
AArch64/AArch64 ARM/ARM BPF/BPF Mips/Mips PowerPC/PPC RISCV/RISCV \
X86/X86
. for hdr in \
AsmMatcher/-gen-asm-matcher \
AsmWriter/-gen-asm-writer \
AsmWriter1/-gen-asm-writer,-asmwriternum=1 \
CallingConv/-gen-callingconv \
CodeEmitter/-gen-emitter \
CompressInstEmitter/-gen-compress-inst-emitter \
DAGISel/-gen-dag-isel \
DisassemblerTables/-gen-disassembler \
EVEX2VEXTables/-gen-x86-EVEX2VEX-tables \
FastISel/-gen-fast-isel \
GlobalISel/-gen-global-isel \
InstrInfo/-gen-instr-info \
MCCodeEmitter/-gen-emitter \
MCPseudoLowering/-gen-pseudo-lowering \
O0PreLegalizeGICombiner/-gen-global-isel-combiner,-combiners=${arch:H}O0PreLegalizerCombinerHelper \
PostLegalizeGICombiner/-gen-global-isel-combiner,-combiners=${arch:H}PostLegalizerCombinerHelper \
PostLegalizeGILowering/-gen-global-isel-combiner,-combiners=${arch:H}PostLegalizerLoweringHelper \
PreLegalizeGICombiner/-gen-global-isel-combiner,-combiners=${arch:H}PreLegalizerCombinerHelper \
RegisterBank/-gen-register-bank \
RegisterInfo/-gen-register-info \
SearchableTables/-gen-searchable-tables \
SubtargetInfo/-gen-subtarget \
SystemOperands/-gen-searchable-tables \
SystemRegister/-gen-searchable-tables
${arch:T}Gen${hdr:H}.inc: ${LLVM_SRCS}/lib/Target/${arch:H}/${arch:T}.td
${LLVM_TBLGEN} ${hdr:T:C/,/ /g} \
-I ${LLVM_SRCS}/include -I ${LLVM_SRCS}/lib/Target/${arch:H} \
-d ${.TARGET}.d -o ${.TARGET} \
${LLVM_SRCS}/lib/Target/${arch:H}/${arch:T}.td
. endfor
.endfor
.if ${MK_LLVM_TARGET_AARCH64} != "no"
TGHDRS+= AArch64GenAsmMatcher.inc
TGHDRS+= AArch64GenAsmWriter.inc
TGHDRS+= AArch64GenAsmWriter1.inc
TGHDRS+= AArch64GenCallingConv.inc
TGHDRS+= AArch64GenDAGISel.inc
TGHDRS+= AArch64GenDisassemblerTables.inc
TGHDRS+= AArch64GenFastISel.inc
TGHDRS+= AArch64GenGlobalISel.inc
TGHDRS+= AArch64GenInstrInfo.inc
TGHDRS+= AArch64GenMCCodeEmitter.inc
TGHDRS+= AArch64GenMCPseudoLowering.inc
TGHDRS+= AArch64GenO0PreLegalizeGICombiner.inc
TGHDRS+= AArch64GenPostLegalizeGICombiner.inc
TGHDRS+= AArch64GenPostLegalizeGILowering.inc
TGHDRS+= AArch64GenPreLegalizeGICombiner.inc
TGHDRS+= AArch64GenRegisterBank.inc
TGHDRS+= AArch64GenRegisterInfo.inc
TGHDRS+= AArch64GenSubtargetInfo.inc
TGHDRS+= AArch64GenSystemOperands.inc
.endif # MK_LLVM_TARGET_AARCH64
.if ${MK_LLVM_TARGET_ARM} != "no"
TGHDRS+= ARMGenAsmMatcher.inc
TGHDRS+= ARMGenAsmWriter.inc
TGHDRS+= ARMGenCallingConv.inc
TGHDRS+= ARMGenDAGISel.inc
TGHDRS+= ARMGenDisassemblerTables.inc
TGHDRS+= ARMGenFastISel.inc
TGHDRS+= ARMGenGlobalISel.inc
TGHDRS+= ARMGenInstrInfo.inc
TGHDRS+= ARMGenMCCodeEmitter.inc
TGHDRS+= ARMGenMCPseudoLowering.inc
TGHDRS+= ARMGenRegisterBank.inc
TGHDRS+= ARMGenRegisterInfo.inc
TGHDRS+= ARMGenSubtargetInfo.inc
TGHDRS+= ARMGenSystemRegister.inc
.endif # MK_LLVM_TARGET_ARM
.if ${MK_LLVM_TARGET_BPF} != "no"
TGHDRS+= BPFGenAsmMatcher.inc
TGHDRS+= BPFGenAsmWriter.inc
TGHDRS+= BPFGenCallingConv.inc
TGHDRS+= BPFGenDAGISel.inc
TGHDRS+= BPFGenDisassemblerTables.inc
TGHDRS+= BPFGenInstrInfo.inc
TGHDRS+= BPFGenMCCodeEmitter.inc
TGHDRS+= BPFGenRegisterInfo.inc
TGHDRS+= BPFGenSubtargetInfo.inc
.endif # MK_LLVM_TARGET_BPF
.if ${MK_LLVM_TARGET_MIPS} != "no"
TGHDRS+= MipsGenAsmMatcher.inc
TGHDRS+= MipsGenAsmWriter.inc
TGHDRS+= MipsGenCallingConv.inc
TGHDRS+= MipsGenDAGISel.inc
TGHDRS+= MipsGenDisassemblerTables.inc
TGHDRS+= MipsGenFastISel.inc
TGHDRS+= MipsGenGlobalISel.inc
TGHDRS+= MipsGenInstrInfo.inc
TGHDRS+= MipsGenMCCodeEmitter.inc
TGHDRS+= MipsGenMCPseudoLowering.inc
TGHDRS+= MipsGenRegisterBank.inc
TGHDRS+= MipsGenRegisterInfo.inc
TGHDRS+= MipsGenSubtargetInfo.inc
.endif # MK_LLVM_TARGET_MIPS
.if ${MK_LLVM_TARGET_POWERPC} != "no"
TGHDRS+= PPCGenAsmMatcher.inc
TGHDRS+= PPCGenAsmWriter.inc
TGHDRS+= PPCGenCallingConv.inc
TGHDRS+= PPCGenDAGISel.inc
TGHDRS+= PPCGenDisassemblerTables.inc
TGHDRS+= PPCGenFastISel.inc
TGHDRS+= PPCGenGlobalISel.inc
TGHDRS+= PPCGenInstrInfo.inc
TGHDRS+= PPCGenMCCodeEmitter.inc
TGHDRS+= PPCGenRegisterBank.inc
TGHDRS+= PPCGenRegisterInfo.inc
TGHDRS+= PPCGenSubtargetInfo.inc
.endif # MK_LLVM_TARGET_POWERPC
.if ${MK_LLVM_TARGET_RISCV} != "no"
TGHDRS+= RISCVGenAsmMatcher.inc
TGHDRS+= RISCVGenAsmWriter.inc
TGHDRS+= RISCVGenCallingConv.inc
TGHDRS+= RISCVGenCompressInstEmitter.inc
TGHDRS+= RISCVGenDAGISel.inc
TGHDRS+= RISCVGenDisassemblerTables.inc
TGHDRS+= RISCVGenDAGISel.inc
TGHDRS+= RISCVGenGlobalISel.inc
TGHDRS+= RISCVGenInstrInfo.inc
TGHDRS+= RISCVGenMCCodeEmitter.inc
TGHDRS+= RISCVGenMCPseudoLowering.inc
TGHDRS+= RISCVGenRegisterBank.inc
TGHDRS+= RISCVGenRegisterInfo.inc
TGHDRS+= RISCVGenSearchableTables.inc
TGHDRS+= RISCVGenSubtargetInfo.inc
TGHDRS+= RISCVGenSystemOperands.inc
.endif # MK_LLVM_TARGET_RISCV
.if ${MK_LLVM_TARGET_X86} != "no"
TGHDRS+= X86GenAsmMatcher.inc
TGHDRS+= X86GenAsmWriter.inc
TGHDRS+= X86GenAsmWriter1.inc
TGHDRS+= X86GenCallingConv.inc
TGHDRS+= X86GenDAGISel.inc
TGHDRS+= X86GenDisassemblerTables.inc
TGHDRS+= X86GenEVEX2VEXTables.inc
TGHDRS+= X86GenFastISel.inc
TGHDRS+= X86GenGlobalISel.inc
TGHDRS+= X86GenInstrInfo.inc
TGHDRS+= X86GenRegisterBank.inc
TGHDRS+= X86GenRegisterInfo.inc
TGHDRS+= X86GenSubtargetInfo.inc
.endif # MK_LLVM_TARGET_X86
DEPENDFILES+= ${TGHDRS:C/$/.d/}
DPSRCS+= ${TGHDRS}
CLEANFILES+= ${TGHDRS} ${TGHDRS:C/$/.d/}
CLEANFILES+= ${GENSRCS} ${GENSRCS:C/$/.d/}
.include "../llvm.build.mk"
.include <bsd.lib.mk>
diff --git a/lib/libgcc_eh/Makefile b/lib/libgcc_eh/Makefile
index 6f2deda1adf0..52584e374e20 100644
--- a/lib/libgcc_eh/Makefile
+++ b/lib/libgcc_eh/Makefile
@@ -1,24 +1,26 @@
# $FreeBSD$
.include <src.opts.mk>
PACKAGE= clibs
LIB= gcc_eh
NO_PIC=
MK_SSP= no
WARNS?= 2
SRCS_EXC+= int_util.c
.include "Makefile.inc"
INCS+= ${UNWINDINCDIR}/__libunwind_config.h
INCS+= ${UNWINDINCDIR}/libunwind.h
INCS+= ${UNWINDINCDIR}/unwind.h
+INCS+= ${UNWINDINCDIR}/unwind_arm_ehabi.h
+INCS+= ${UNWINDINCDIR}/unwind_itanium.h
.if ${.MAKE.LEVEL} > 0
# avoid circular dependencies
GENDIRDEPS_FILTER+= Nlib/msun
CFLAGS+= -I${SRCTOP}/lib/msun/src
.endif
.include <bsd.lib.mk>
diff --git a/lib/libomp/kmp_config.h b/lib/libomp/kmp_config.h
index fd25b7404178..7d11e27cc4b1 100644
--- a/lib/libomp/kmp_config.h
+++ b/lib/libomp/kmp_config.h
@@ -1,143 +1,190 @@
-// $FreeBSD$
/*
* kmp_config.h -- Feature macros
*/
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef KMP_CONFIG_H
#define KMP_CONFIG_H
#include "kmp_platform.h"
// cmakedefine01 MACRO will define MACRO as either 0 or 1
// cmakedefine MACRO 1 will define MACRO as 1 or leave undefined
#define DEBUG_BUILD 0
#define RELWITHDEBINFO_BUILD 0
#define LIBOMP_USE_ITT_NOTIFY 1
#define USE_ITT_NOTIFY LIBOMP_USE_ITT_NOTIFY
#if ! LIBOMP_USE_ITT_NOTIFY
# define INTEL_NO_ITTNOTIFY_API
#endif
#define LIBOMP_USE_VERSION_SYMBOLS 1
#if LIBOMP_USE_VERSION_SYMBOLS
# define KMP_USE_VERSION_SYMBOLS
#endif
#define LIBOMP_HAVE_WEAK_ATTRIBUTE 1
#define KMP_HAVE_WEAK_ATTRIBUTE LIBOMP_HAVE_WEAK_ATTRIBUTE
#define LIBOMP_HAVE_PSAPI 0
#define KMP_HAVE_PSAPI LIBOMP_HAVE_PSAPI
#define LIBOMP_STATS 0
#define KMP_STATS_ENABLED LIBOMP_STATS
#define LIBOMP_HAVE_X86INTRIN_H 0
#define KMP_HAVE_X86INTRIN_H LIBOMP_HAVE_X86INTRIN_H
#define LIBOMP_HAVE___BUILTIN_READCYCLECOUNTER 0
#define KMP_HAVE___BUILTIN_READCYCLECOUNTER LIBOMP_HAVE___BUILTIN_READCYCLECOUNTER
#define LIBOMP_HAVE___RDTSC 0
#define KMP_HAVE___RDTSC LIBOMP_HAVE___RDTSC
#define LIBOMP_USE_DEBUGGER 0
#define USE_DEBUGGER LIBOMP_USE_DEBUGGER
#define LIBOMP_OMPT_DEBUG 0
#define OMPT_DEBUG LIBOMP_OMPT_DEBUG
#define LIBOMP_OMPT_SUPPORT 1
#define OMPT_SUPPORT LIBOMP_OMPT_SUPPORT
#define LIBOMP_OMPD_SUPPORT 0
#define OMPD_SUPPORT LIBOMP_OMPD_SUPPORT
#define LIBOMP_PROFILING_SUPPORT 0
#define OMP_PROFILING_SUPPORT LIBOMP_PROFILING_SUPPORT
#define LIBOMP_OMPT_OPTIONAL 1
#define OMPT_OPTIONAL LIBOMP_OMPT_OPTIONAL
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 // FreeBSD customization {
#define LIBOMP_USE_ADAPTIVE_LOCKS 1
+#else
+#define LIBOMP_USE_ADAPTIVE_LOCKS 0
+#endif // } FreeBSD customization
#define KMP_USE_ADAPTIVE_LOCKS LIBOMP_USE_ADAPTIVE_LOCKS
#define KMP_DEBUG_ADAPTIVE_LOCKS 0
#define LIBOMP_USE_INTERNODE_ALIGNMENT 0
#define KMP_USE_INTERNODE_ALIGNMENT LIBOMP_USE_INTERNODE_ALIGNMENT
#define LIBOMP_ENABLE_ASSERTIONS 1
#define KMP_USE_ASSERT LIBOMP_ENABLE_ASSERTIONS
#define LIBOMP_USE_HIER_SCHED 0
#define KMP_USE_HIER_SCHED LIBOMP_USE_HIER_SCHED
#define STUBS_LIBRARY 0
#define LIBOMP_USE_HWLOC 0
#define KMP_USE_HWLOC LIBOMP_USE_HWLOC
#define LIBOMP_ENABLE_SHARED 1
#define KMP_DYNAMIC_LIB LIBOMP_ENABLE_SHARED
+#if KMP_ARCH_X86 // FreeBSD customization {
+#define KMP_ARCH_STR "IA-32"
+#elif KMP_ARCH_X86_64
#define KMP_ARCH_STR "Intel(R) 64"
+#elif KMP_ARCH_AARCH64
+#define KMP_ARCH_STR "AARCH64"
+#elif KMP_ARCH_PPC64
+#define KMP_ARCH_STR "PPC64BE"
+#elif KMP_ARCH_MIPS
+#define KMP_ARCH_STR "MIPS"
+#elif KMP_ARCH_MIPS64
+#define KMP_ARCH_STR "MIPS64"
+#elif KMP_ARCH_RISCV64
+#define KMP_ARCH_STR "RISCV64"
+#else
+#error Unknown KMP_ARCH value
+#endif // } FreeBSD customization
#define KMP_LIBRARY_FILE "libomp.so"
#define KMP_VERSION_MAJOR 5
#define KMP_VERSION_MINOR 0
#define MSVC 0
#define KMP_MSVC_COMPAT MSVC
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 // FreeBSD customization {
#define LIBOMP_HAVE_WAITPKG_INTRINSICS 1
+#else
+#define LIBOMP_HAVE_WAITPKG_INTRINSICS 0
+#endif // } FreeBSD customization
#define KMP_HAVE_WAITPKG_INTRINSICS LIBOMP_HAVE_WAITPKG_INTRINSICS
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 // FreeBSD customization {
#define LIBOMP_HAVE_RTM_INTRINSICS 1
+#else
+#define LIBOMP_HAVE_RTM_INTRINSICS 0
+#endif // } FreeBSD customization
#define KMP_HAVE_RTM_INTRINSICS LIBOMP_HAVE_RTM_INTRINSICS
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 // FreeBSD customization {
#define LIBOMP_HAVE_IMMINTRIN_H 1
+#else
+#define LIBOMP_HAVE_IMMINTRIN_H 0
+#endif // } FreeBSD customization
#define KMP_HAVE_IMMINTRIN_H LIBOMP_HAVE_IMMINTRIN_H
#define LIBOMP_HAVE_INTRIN_H 0
#define KMP_HAVE_INTRIN_H LIBOMP_HAVE_INTRIN_H
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 // FreeBSD customization {
#define LIBOMP_HAVE_ATTRIBUTE_WAITPKG 1
+#else
+#define LIBOMP_HAVE_ATTRIBUTE_WAITPKG 0
+#endif // } FreeBSD customization
#define KMP_HAVE_ATTRIBUTE_WAITPKG LIBOMP_HAVE_ATTRIBUTE_WAITPKG
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 // FreeBSD customization {
#define LIBOMP_HAVE_ATTRIBUTE_RTM 1
+#else
+#define LIBOMP_HAVE_ATTRIBUTE_RTM 0
+#endif // } FreeBSD customization
#define KMP_HAVE_ATTRIBUTE_RTM LIBOMP_HAVE_ATTRIBUTE_RTM
#define LIBOMP_ARCH_AARCH64_A64FX 0
#define KMP_ARCH_AARCH64_A64FX LIBOMP_ARCH_AARCH64_A64FX
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 // FreeBSD customization {
#define LIBOMP_HAVE_XMMINTRIN_H 1
+#else
+#define LIBOMP_HAVE_XMMINTRIN_H 0
+#endif // } FreeBSD customization
#define KMP_HAVE_XMMINTRIN_H LIBOMP_HAVE_XMMINTRIN_H
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 // FreeBSD customization {
#define LIBOMP_HAVE__MM_MALLOC 1
+#else
+#define LIBOMP_HAVE__MM_MALLOC 0
+#endif // } FreeBSD customization
#define KMP_HAVE__MM_MALLOC LIBOMP_HAVE__MM_MALLOC
#define LIBOMP_HAVE_ALIGNED_ALLOC 1
#define KMP_HAVE_ALIGNED_ALLOC LIBOMP_HAVE_ALIGNED_ALLOC
#define LIBOMP_HAVE_POSIX_MEMALIGN 1
#define KMP_HAVE_POSIX_MEMALIGN LIBOMP_HAVE_POSIX_MEMALIGN
#define LIBOMP_HAVE__ALIGNED_MALLOC 0
#define KMP_HAVE__ALIGNED_MALLOC LIBOMP_HAVE__ALIGNED_MALLOC
// Configured cache line based on architecture
#if KMP_ARCH_PPC64
# define CACHE_LINE 128
#elif KMP_ARCH_AARCH64_A64FX
# define CACHE_LINE 256
#else
# define CACHE_LINE 64
#endif
#if ! KMP_32_BIT_ARCH
# define BUILD_I8 1
#endif
#define KMP_NESTED_HOT_TEAMS 1
#define KMP_ADJUST_BLOCKTIME 1
#define BUILD_PARALLEL_ORDERED 1
#define KMP_ASM_INTRINS 1
#define USE_ITT_BUILD LIBOMP_USE_ITT_NOTIFY
#define INTEL_ITTNOTIFY_PREFIX __kmp_itt_
#if ! KMP_MIC
# define USE_LOAD_BALANCE 1
#endif
#if ! (KMP_OS_WINDOWS || KMP_OS_DARWIN)
# define KMP_TDATA_GTID 1
#endif
#if STUBS_LIBRARY
# define KMP_STUB 1
#endif
#if DEBUG_BUILD || RELWITHDEBINFO_BUILD
# define KMP_DEBUG 1
#endif
#if KMP_OS_WINDOWS
# define KMP_WIN_CDECL
#else
# define BUILD_TV
# define KMP_GOMP_COMPAT
#endif
// use shared memory with dynamic library (except Android, where shm_*
// functions don't exist).
#if KMP_OS_UNIX && KMP_DYNAMIC_LIB && !__ANDROID__
#define KMP_USE_SHM
#endif
#endif // KMP_CONFIG_H
diff --git a/lib/libomp/kmp_i18n_default.inc b/lib/libomp/kmp_i18n_default.inc
index f10caed57de6..5c59f8b7778c 100644
--- a/lib/libomp/kmp_i18n_default.inc
+++ b/lib/libomp/kmp_i18n_default.inc
@@ -1,478 +1,486 @@
-// $FreeBSD$
// Do not edit this file! //
-// The file was generated from en_US.txt by message-converter.pl on Mon Nov 22 22:46:03 2021. //
+// The file was generated from en_US.txt by message-converter.pl on Sat Feb 5 21:17:04 2022. //
static char const *
__kmp_i18n_default_meta[] =
{
NULL,
"English",
"USA",
"1033",
"2",
"20170523",
NULL
};
static char const *
__kmp_i18n_default_strings[] =
{
NULL,
"Error",
"(unknown file)",
"not a number",
"bad unit",
"illegal characters",
"value too large",
"value too small",
"value is not a multiple of 4k",
"Unknown processor topology",
"Cannot open /proc/cpuinfo",
"/proc/cpuinfo",
"cpuinfo file invalid (No processor records)",
"cpuinfo file invalid (Too many processor records)",
"Cannot rewind cpuinfo file",
"cpuinfo file invalid (long line)",
"cpuinfo file contains too many entries",
"cpuinfo file missing processor field",
"cpuinfo file missing physical id field",
"cpuinfo file invalid (missing val)",
"cpuinfo file invalid (duplicate field)",
"Physical node/pkg/core/thread ids not unique",
"APIC not present",
"Invalid cpuid info",
"APIC ids not unique",
"Inconsistent cpuid info",
"Out of heap memory",
"Memory allocation failed",
"core",
"thread",
"package",
"node",
"<undef>",
"decoding legacy APIC ids",
"parsing /proc/cpuinfo",
"value is not defined",
"Effective settings:",
"User settings:",
"warning: pointers or size don't make sense",
"CPU",
"TPU",
"TPUs per package",
"HT enabled",
"HT disabled",
"decoding x2APIC ids",
"cpuid leaf 11 not supported",
"cpuid leaf 4 not supported",
"thread ids not unique",
"using pthread info",
"legacy APIC ids not unique",
"x2APIC ids not unique",
"OPENMP DISPLAY ENVIRONMENT BEGIN",
"OPENMP DISPLAY ENVIRONMENT END",
"[device]",
"[host]",
"tile",
"tiles",
"threads",
"cores",
"socket",
"sockets",
"die",
"dice",
"module",
"modules",
"L1 cache",
"L1 caches",
"L2 cache",
"L2 caches",
"L3 cache",
"L3 caches",
"NUMA domain",
"NUMA domains",
"processor group",
"processor groups",
"unknown",
"cpuid leaf 31 not supported",
"Hwloc api failure",
"LL cache",
"LL caches",
NULL
};
static char const *
__kmp_i18n_default_formats[] =
{
NULL,
"OMP: Info #%1$d: %2$s\n",
"OMP: Warning #%1$d: %2$s\n",
"OMP: Error #%1$d: %2$s\n",
"OMP: System error #%1$d: %2$s\n",
"OMP: Hint %1$s\n",
"%1$s pragma (at %2$s:%3$s():%4$s)",
NULL
};
static char const *
__kmp_i18n_default_messages[] =
{
NULL,
"Library is \"serial\".",
"Cannot open message catalog \"%1$s\":",
"Default messages will be used.",
"%1$s: Lock is uninitialized",
"%1$s: Lock was initialized as simple, but used as nestable",
"%1$s: Lock was initialized as nestable, but used as simple",
"%1$s: Lock is already owned by requesting thread",
"%1$s: Lock is still owned by a thread",
"%1$s: Attempt to release a lock not owned by any thread",
"%1$s: Attempt to release a lock owned by another thread",
"Stack overflow detected for OpenMP thread #%1$d",
"Stack overlap detected. ",
"Assertion failure at %1$s(%2$d).",
"Unable to register a new user thread.",
"Initializing %1$s, but found %2$s already initialized.",
"Cannot open file \"%1$s\" for reading:",
"Getting environment variable \"%1$s\" failed:",
"Setting environment variable \"%1$s\" failed:",
"Getting environment failed:",
"%1$s=\"%2$s\": Wrong value, boolean expected.",
"No Helper Thread support built in this OMP library.",
"Helper thread failed to soft terminate.",
"Buffer overflow detected.",
"Real-time scheduling policy is not supported.",
"OMP application is running at maximum priority with real-time scheduling policy. ",
"Changing priority of the monitor thread failed:",
"Deadlocks are highly possible due to monitor thread starvation.",
"Unable to set monitor thread stack size to %1$lu bytes:",
"Unable to set OMP thread stack size to %1$lu bytes:",
"Thread attribute initialization failed:",
"Thread attribute destroying failed:",
"OMP thread joinable state setting failed:",
"Monitor thread joinable state setting failed:",
"System unable to allocate necessary resources for OMP thread:",
"System unable to allocate necessary resources for the monitor thread:",
"Unable to terminate OMP thread:",
"Wrong schedule type %1$d, see <omp.h> or <omp_lib.h> file for the list of values supported.",
"Unknown scheduling type \"%1$d\".",
"%1$s value \"%2$s\" is invalid.",
"%1$s value \"%2$s\" is too small.",
"%1$s value \"%2$s\" is too large.",
"%1$s: \"%2$s\" is an invalid value; ignored.",
"%1$s release value \"%2$s\" is invalid.",
"%1$s gather value \"%2$s\" is invalid.",
"%1$s supported only on debug builds; ignored.",
"Syntax error: Usage: %1$s=[ routine=<func> | filename=<file> | range=<lb>:<ub> | excl_range=<lb>:<ub> ],...",
"Unbalanced quotes in %1$s.",
"Empty string specified for %1$s; ignored.",
"%1$s value is too long; ignored.",
"%1$s: Invalid clause in \"%2$s\".",
"Empty clause in %1$s.",
"%1$s value \"%2$s\" is invalid chunk size.",
"%1$s value \"%2$s\" is to large chunk size.",
"%1$s value \"%2$s\" is ignored.",
"Cannot get processor frequency, using zero KMP_ITT_PREPARE_DELAY.",
"%1$s must be set prior to first parallel region; ignored.",
"%1$s: parameter has been specified already, ignoring \"%2$s\".",
"%1$s: parameter invalid, ignoring \"%2$s\".",
"%1$s: too many integer parameters specified, ignoring \"%2$s\".",
"%1$s: too many integer parameters specified for logical or physical type, ignoring \"%2$d\".",
"%1$s: '%2$s' type does not take any integer parameters, ignoring them.",
"%1$s: proclist not specified with explicit affinity type, using \"none\".",
"%1$s: proclist specified, setting affinity type to \"explicit\".",
"%1$s: proclist specified without \"explicit\" affinity type, proclist ignored.",
"%1$s: syntax error, not using affinity.",
"%1$s: range error (zero stride), not using affinity.",
"%1$s: range error (%2$d > %3$d), not using affinity.",
"%1$s: range error (%2$d < %3$d & stride < 0), not using affinity.",
"%1$s: range error ((%2$d-%3$d)/%4$d too big), not using affinity.",
"%1$s: %2$s is defined. %3$s will be ignored.",
"%1$s: affinity not supported, using \"disabled\".",
"%1$s: affinity only supported for Intel(R) Architecture Processors.",
"%1$s: getaffinity system call not supported.",
"%1$s: setaffinity system call not supported.",
"%1$s: pthread_aff_set_np call not found.",
"%1$s: pthread_get_num_resources_np call not found.",
"%1$s: the OS kernel does not support affinity.",
"%1$s: pthread_get_num_resources_np returned %2$d.",
"%1$s: cannot determine proper affinity mask size.",
"%1$s=\"%2$s\": %3$s.",
"%1$s: extra trailing characters ignored: \"%2$s\".",
"%1$s: unknown method \"%2$s\".",
"KMP_STATS_TIMER: clock_gettime is undefined, using gettimeofday.",
"KMP_STATS_TIMER: \"%1$s\" needs additional parameter, e.g. 'clock_gettime,2'. Using gettimeofday.",
"KMP_STATS_TIMER: clock_gettime parameter \"%1$s\" is invalid, using gettimeofday.",
"KMP_STATS_TIMER: clock_gettime failed, using gettimeofday.",
"KMP_STATS_TIMER: clock function unknown (ignoring value \"%1$s\").",
"Unknown scheduling type detected.",
"Too many threads to use analytical guided scheduling - switching to iterative guided scheduling.",
"ittnotify: Lookup of \"%1$s\" function in \"%2$s\" library failed.",
"ittnotify: Loading \"%1$s\" library failed.",
"ittnotify: All itt notifications disabled.",
"ittnotify: Object state itt notifications disabled.",
"ittnotify: Mark itt notifications disabled.",
"ittnotify: Unloading \"%1$s\" library failed.",
"Cannot form a team with %1$d threads, using %2$d instead.",
"Requested number of active parallel levels \"%1$d\" is negative; ignored.",
"Requested number of active parallel levels \"%1$d\" exceeds supported limit; the following limit value will be used: \"%1$d\".",
"kmp_set_library must only be called from the top level serial thread; ignored.",
"Fatal system error detected.",
"Out of heap memory.",
"Clearing __KMP_REGISTERED_LIB env var failed.",
"Registering library with env var failed.",
"%1$s value \"%2$d\" will be used.",
"%1$s value \"%2$u\" will be used.",
"%1$s value \"%2$s\" will be used.",
"%1$s value \"%2$s\" will be used.",
"Mixing other barrier patterns with dist is prohibited. Using dist for all barrier patterns.",
"%1$s maximum value \"%2$d\" will be used.",
"%1$s minimum value \"%2$d\" will be used.",
"Memory allocation failed.",
"File name too long.",
"Lock table overflow.",
"Too many threads to use threadprivate directive.",
"%1$s: invalid mask.",
"Wrong definition.",
"Windows* OS: TLS Set Value failed.",
"Windows* OS: TLS out of indexes.",
"PDONE directive must be nested within a DO directive.",
"Cannot get number of available CPUs.",
"Assumed number of CPUs is 2.",
"Error initializing affinity - not using affinity.",
"Threads may migrate across all available OS procs (granularity setting too coarse).",
"Ignoring invalid OS proc ID %1$d.",
"No valid OS proc IDs specified - not using affinity.",
"%1$s - using \"flat\" OS <-> physical proc mapping.",
"%1$s: %2$s - using \"flat\" OS <-> physical proc mapping.",
"%1$s, line %2$d: %3$s - using \"flat\" OS <-> physical proc mapping.",
"%1$s: %2$s - exiting.",
"%1$s, line %2$d: %3$s - exiting.",
"Construct identifier invalid.",
"Thread identifier invalid.",
"runtime library not initialized.",
"Inconsistent THREADPRIVATE common block declarations are non-conforming and are unsupported. Either all threadprivate common blocks must be declared identically, or the largest instance of each threadprivate common block must be referenced first during the run.",
"Cannot set thread affinity mask.",
"Cannot set thread priority.",
"Cannot create thread.",
"Cannot create event.",
"Cannot set event.",
"Cannot close handle.",
"Unknown library type: %1$d.",
"Monitor did not reap properly.",
"Worker thread failed to join.",
"Cannot change thread affinity mask.",
"%1$s: Threads may migrate across %2$d innermost levels of machine",
"%1$s: decrease to %2$d threads",
"%1$s: increase to %2$d threads",
"%1$s: Internal thread %2$d bound to OS proc set %3$s",
"%1$s: Affinity capable, using cpuinfo file",
"%1$s: Affinity capable, using global cpuid info",
"%1$s: Affinity capable, using default \"flat\" topology",
"%1$s: Affinity not capable, using local cpuid info",
"%1$s: Affinity not capable, using cpuinfo file",
"%1$s: Affinity not capable, assuming \"flat\" topology",
"%1$s: Initial OS proc set respected: %2$s",
"%1$s: Initial OS proc set not respected: %2$s",
"%1$s: %2$d available OS procs",
"%1$s: Uniform topology",
"%1$s: Nonuniform topology",
"%1$s: %2$d packages x %3$d cores/pkg x %4$d threads/core (%5$d total cores)",
"%1$s: OS proc to physical thread map ([] => level not in map):",
"%1$s: OS proc <n> maps to <n>th package core 0",
"%1$s: OS proc %2$d maps to package %3$d [core %4$d] [thread %5$d]",
"%1$s: OS proc %2$d maps to [package %3$d] [core %4$d] [thread %5$d]",
"%1$s: OS proc %2$d maps to [package %3$d] [core %4$d] thread %5$d",
"%1$s: OS proc %2$d maps to [package %3$d] core %4$d [thread %5$d]",
"%1$s: OS proc %2$d maps to package %3$d [core %4$d] [thread %5$d]",
"%1$s: OS proc %2$d maps to [package %3$d] core %4$d thread %5$d",
"%1$s: OS proc %2$d maps to package %3$d core %4$d [thread %5$d]",
"%1$s: OS proc %2$d maps to package %3$d [core %4$d] thread %5$d",
"%1$s: OS proc %2$d maps to package %3$d core %4$d thread %5$d",
"%1$s: OS proc %2$d maps to %3$s",
"%1$s: Internal thread %2$d changed affinity mask from %3$s to %4$s",
"%1$s: OS proc %2$d maps to package %3$d, CPU %4$d, TPU %5$d",
"%1$s: OS proc %2$d maps to package %3$d, CPU %4$d",
"%1$s: HT enabled; %2$d packages; %3$d TPU; %4$d TPUs per package",
"%1$s: HT disabled; %2$d packages",
"Threads encountered barriers in different order. ",
"Function %1$s failed:",
"%1$s: %2$s packages x %3$d cores/pkg x %4$d threads/core (%5$d total cores)",
"Incompatible message catalog \"%1$s\": Version \"%2$s\" found, version \"%3$s\" expected.",
"%1$s: ignored because %2$s has been defined",
"%1$s: overrides %3$s specified before",
"%1$s: Tiles are only supported if KMP_TOPOLOGY_METHOD=hwloc, using granularity=package instead",
"%1$s: Tiles requested but were not detected on this HW, using granularity=package instead",
"%1$s: %2$d packages x %3$d tiles/pkg x %4$d cores/tile x %5$d threads/core (%6$d total cores)",
"%1$s: %2$d packages x %3$d nodes/pkg x %4$d cores/node x %5$d threads/core (%6$d total cores)",
"%1$s: %2$d packages x %3$d nodes/pkg x %4$d tiles/node x %5$d cores/tile x %6$d threads/core (%7$d total cores)",
"OMPT: Cannot determine workshare type; using the default (loop) instead. This issue is fixed in an up-to-date compiler.",
"Allocator %1$s is not available, will use default allocator.",
"%1$s: %2$s (%3$d total cores)",
"%1$s: granularity setting: %2$s does not exist in topology. Using granularity=%3$s instead.",
"%1$s: hybrid core type detected: %2$d %3$s cores.",
+ "%1$s: %2$d with core efficiency %3$d.",
"%1$s must be bound to a work-sharing or work-queuing construct with an \"ordered\" clause",
"Detected end of %1$s without first executing a corresponding beginning.",
"Iteration range too large in %1$s.",
"%1$s must not have a loop increment that evaluates to zero.",
"Expected end of %1$s; %2$s, however, has most recently begun execution.",
"%1$s is incorrectly nested within %2$s",
"%1$s cannot be executed multiple times during execution of one parallel iteration/section of %2$s",
"%1$s is incorrectly nested within %2$s of the same name",
"%1$s is incorrectly nested within %2$s that does not have an \"ordered\" clause",
"%1$s is incorrectly nested within %2$s but not within any of its \"task\" constructs",
"One thread at %1$s while another thread is at %2$s.",
"Cannot connect to %1$s",
"Cannot connect to %1$s - Using %2$s",
"%1$s does not support %2$s. Continuing without using %2$s.",
"%1$s does not support %2$s for %3$s. Continuing without using %2$s.",
"Static %1$s does not support %2$s. Continuing without using %2$s.",
"KMP_DYNAMIC_MODE=irml cannot be used with KMP_USE_IRML=0",
"ittnotify: Unknown group \"%2$s\" specified in environment variable \"%1$s\".",
"ittnotify: Environment variable \"%1$s\" too long: Actual lengths is %2$lu, max allowed length is %3$lu.",
"%1$s: Affinity capable, using global cpuid leaf 11 info",
"%1$s: Affinity not capable, using local cpuid leaf 11 info",
"%1$s: %2$s.",
"%1$s: %2$s - %3$s.",
"%1$s: OS proc to physical thread map:",
"%1$s: using \"flat\" OS <-> physical proc mapping.",
"%1$s: parsing %2$s.",
"%1$s - exiting.",
"Incompatible %1$s library with version %2$s found.",
"ittnotify: Function %1$s failed:",
"ittnotify: Error #%1$d.",
"%1$s must be set prior to first parallel region or certain API calls; ignored.",
"Lock initialized at %1$s(%2$d) was not destroyed",
"Cannot determine machine load balance - Using %1$s",
"%1$s: Affinity not capable, using pthread info",
"%1$s: Affinity capable, using pthread info",
"Loading \"%1$s\" library failed:",
"Lookup of \"%1$s\" function failed:",
"Buffer too small.",
"Error #%1$d.",
"%1$s: Invalid symbols found. Check the value \"%2$s\".",
"%1$s: Spaces between digits are not allowed \"%2$s\".",
"%1$s: %2$s - parsing %3$s.",
"%1$s cannot be specified via kmp_set_defaults() on this machine because it has more than one processor group.",
"Cannot use affinity type \"%1$s\" with multiple Windows* OS processor groups, using \"%2$s\".",
"Cannot use affinity granularity \"%1$s\" with multiple Windows* OS processor groups, using \"%2$s\".",
"%1$s: Mapping Windows* OS processor group <i> proc <j> to OS proc 64*<i>+<j>.",
"%1$s: OS proc %2$d maps to Windows* OS processor group %3$d proc %4$d",
"%1$s: Affinity balanced is not available.",
"%1$s: granularity=core will be used.",
"%1$s must be set prior to first OMP lock call or critical section; ignored.",
"futex system call not supported; %1$s=%2$s ignored.",
"%1$s: granularity=%2$s will be used.",
"%1$s: invalid value \"%2$s\", valid format is \"N<item>[@N][,...][,Nt] (<item> can be S, N, L2, C, T for Socket, NUMA Node, L2 Cache, Core, Thread)\".",
"KMP_HW_SUBSET ignored: unsupported architecture.",
"KMP_HW_SUBSET ignored: too many cores requested.",
"%1$s: syntax error, using %2$s.",
"%1$s: Adaptive locks are not supported; using queuing.",
"%1$s: Invalid symbols found. Check the value \"%2$s\".",
"%1$s: Spaces between digits are not allowed \"%2$s\".",
"%1$s: pid %2$d tid %3$d thread %4$d bound to OS proc set %5$s",
"%1$s error: parallel loop increment and condition are inconsistent.",
"libgomp cancellation is not currently supported.",
"KMP_HW_SUBSET ignored: non-uniform topology.",
"KMP_HW_SUBSET ignored: only three-level topology is supported.",
"%1$s: granularity=%2$s is not supported with KMP_TOPOLOGY_METHOD=group. Using \"granularity=fine\".",
"%1$s: granularity=group is not supported with KMP_AFFINITY=%2$s. Using \"granularity=core\".",
"KMP_HW_SUBSET ignored: too many sockets requested.",
"KMP_HW_SUBSET \"o\" offset designator deprecated, please use @ prefix for offset value.",
"%1$s: Affinity capable, using hwloc.",
"%1$s: Ignoring hwloc mechanism.",
"%1$s: Hwloc failed in %2$s. Relying on internal affinity mechanisms.",
"%1$s must be set prior to OpenMP runtime library initialization; ignored.",
"You have enabled the use of umonitor/umwait. If the CPU doesn't have that enabled you'll get an illegal instruction exception.",
"%1$s variable deprecated, please use %2$s instead.",
"KMP_FORCE_REDUCTION: %1$s method is not supported; using critical.",
"KMP_HW_SUBSET ignored: unsupported item requested for non-HWLOC topology method (KMP_TOPOLOGY_METHOD)",
"KMP_HW_SUBSET ignored: too many NUMA Nodes requested.",
"KMP_HW_SUBSET ignored: too many L2 Caches requested.",
"KMP_HW_SUBSET ignored: too many Procs requested.",
"Hierarchy ignored: unsupported level: %1$s.",
"OMP: pid %1$s tid %2$s thread %3$s bound to OS proc set {%4$s}",
"%1$s routine deprecated, please use %2$s instead.",
"libgomp compatibility layer does not support OpenMP feature: %1$s",
"KMP_HW_SUBSET ignored: too many Dies requested.",
"%1$s: Affinity capable, using global cpuid leaf %2$d info",
"%1$s: Affinity not capable, using local cpuid leaf %2$d info",
"%1$s: Affinity not capable, using hwloc.",
"%1$s: Encountered user-directed error: %2$s.",
"%1$s: Encountered user-directed warning: %2$s.",
"Failed to create teams between lower bound (%1$d) and upper bound (%2$d).",
"KMP_HW_SUBSET ignored: %1$s: too many requested.",
"KMP_HW_SUBSET ignored: %1$s: level not detected in machine topology.",
"KMP_HW_SUBSET ignored: %1$s, %2$s: layers are equivalent, please only specify one.",
"KMP_HW_SUBSET ignored: %1$s layer should come after %2$s.",
"%1$s: topology layer \"%2$s\" is equivalent to \"%3$s\".",
"%1$s: granularity=%2$s is too coarse, setting granularity=group.",
"%1$s: \"%2$s\" value is deprecated. Please use \"%3$s\" instead.",
+ "num_teams value must be positive, it is %1$d, using %2$d instead.",
+ "KMP_HW_SUBSET ignored: %1$s, %2$s: attributes are ambiguous, please only specify one.",
+ "KMP_HW_SUBSET ignored: %1$s: attribute specified more than once.",
+ "KMP_HW_SUBSET ignored: %1$s: attribute value %2$s is invalid.",
+ "KMP_HW_SUBSET ignored: all hardware resources would be filtered, please reduce the filter.",
+ "KMP_HW_SUBSET ignored: Too many attributes specified. This machine is not a hybrid architecutre.",
+ "KMP_HW_SUBSET: ignoring %1$s attribute. This machine is not a hybrid architecutre.",
NULL
};
static char const *
__kmp_i18n_default_hints[] =
{
NULL,
"Please submit a bug report with this message, compile and run commands used, and machine configuration info including native compiler and operating system versions. Faster response will be obtained by including all program sources. For information on submitting this issue, please see https://bugs.llvm.org/.",
"Check NLSPATH environment variable, its value is \"%1$s\".",
"Please try changing the shell stack limit or adjusting the OMP_STACKSIZE environment variable.",
"Consider unsetting KMP_DEVICE_THREAD_LIMIT (KMP_ALL_THREADS), KMP_TEAMS_THREAD_LIMIT, and OMP_THREAD_LIMIT (if any are set).",
"Consider setting KMP_ALL_THREADPRIVATE to a value larger than %1$d.",
"This could also be due to a system-related limit on the number of threads.",
"This means that multiple copies of the OpenMP runtime have been linked into the program. That is dangerous, since it can degrade performance or cause incorrect results. The best thing to do is to ensure that only a single OpenMP runtime is linked into the process, e.g. by avoiding static linking of the OpenMP runtime in any library. As an unsafe, unsupported, undocumented workaround you can set the environment variable KMP_DUPLICATE_LIB_OK=TRUE to allow the program to continue to execute, but that may cause crashes or silently produce incorrect results. For more information, please see http://openmp.llvm.org/",
"This name is specified in environment variable KMP_CPUINFO_FILE.",
"Seems application required too much memory.",
"Use \"0\", \"FALSE\". \".F.\", \"off\", \"no\" as false values, \"1\", \"TRUE\", \".T.\", \"on\", \"yes\" as true values.",
"Perhaps too many threads.",
"Decrease priority of application. This will allow the monitor thread run at higher priority than other threads.",
"Try changing KMP_MONITOR_STACKSIZE or the shell stack limit.",
"Try changing OMP_STACKSIZE and/or the shell stack limit.",
"Try increasing OMP_STACKSIZE or the shell stack limit.",
"Try decreasing OMP_STACKSIZE.",
"Try decreasing the value of OMP_NUM_THREADS.",
"Try increasing KMP_MONITOR_STACKSIZE.",
"Try decreasing KMP_MONITOR_STACKSIZE.",
"Try decreasing the number of threads in use simultaneously.",
"Will use default schedule type (%1$s).",
"It could be a result of using an older OMP library with a newer compiler or memory corruption. You may check the proper OMP library is linked to the application.",
"Check %1$s environment variable, its value is \"%2$s\".",
"You may want to use an %1$s library that supports %2$s interface with version %3$s.",
"You may want to use an %1$s library with version %2$s.",
"System error #193 is \"Bad format of EXE or DLL file\". Usually it means the file is found, but it is corrupted or a file for another architecture. Check whether \"%1$s\" is a file for %2$s architecture.",
"System-related limit on the number of threads.",
"Try setting new bounds (preferably less than or equal to %1$d) for num_teams clause.",
+ "Valid values are from %1$d to %2$d.",
NULL
};
struct kmp_i18n_section {
int size;
char const ** str;
}; // struct kmp_i18n_section
typedef struct kmp_i18n_section kmp_i18n_section_t;
static kmp_i18n_section_t
__kmp_i18n_sections[] =
{
{ 0, NULL },
{ 5, __kmp_i18n_default_meta },
{ 79, __kmp_i18n_default_strings },
{ 6, __kmp_i18n_default_formats },
- { 290, __kmp_i18n_default_messages },
- { 28, __kmp_i18n_default_hints },
+ { 298, __kmp_i18n_default_messages },
+ { 29, __kmp_i18n_default_hints },
{ 0, NULL }
};
struct kmp_i18n_table {
int size;
kmp_i18n_section_t * sect;
}; // struct kmp_i18n_table
typedef struct kmp_i18n_table kmp_i18n_table_t;
static kmp_i18n_table_t __kmp_i18n_default_table =
{
5,
__kmp_i18n_sections
};
// end of file //
diff --git a/lib/libomp/kmp_i18n_id.inc b/lib/libomp/kmp_i18n_id.inc
index 4ef2ea7a7c41..46127e4fef8f 100644
--- a/lib/libomp/kmp_i18n_id.inc
+++ b/lib/libomp/kmp_i18n_id.inc
@@ -1,445 +1,453 @@
-// $FreeBSD$
// Do not edit this file! //
-// The file was generated from en_US.txt by message-converter.pl on Mon Nov 22 22:46:03 2021. //
+// The file was generated from en_US.txt by message-converter.pl on Sat Feb 5 21:17:04 2022. //
enum kmp_i18n_id {
// A special id for absence of message.
kmp_i18n_null = 0,
// Set #1, meta.
kmp_i18n_prp_first = 65536,
kmp_i18n_prp_Language,
kmp_i18n_prp_Country,
kmp_i18n_prp_LangId,
kmp_i18n_prp_Version,
kmp_i18n_prp_Revision,
kmp_i18n_prp_last,
// Set #2, strings.
kmp_i18n_str_first = 131072,
kmp_i18n_str_Error,
kmp_i18n_str_UnknownFile,
kmp_i18n_str_NotANumber,
kmp_i18n_str_BadUnit,
kmp_i18n_str_IllegalCharacters,
kmp_i18n_str_ValueTooLarge,
kmp_i18n_str_ValueTooSmall,
kmp_i18n_str_NotMultiple4K,
kmp_i18n_str_UnknownTopology,
kmp_i18n_str_CantOpenCpuinfo,
kmp_i18n_str_ProcCpuinfo,
kmp_i18n_str_NoProcRecords,
kmp_i18n_str_TooManyProcRecords,
kmp_i18n_str_CantRewindCpuinfo,
kmp_i18n_str_LongLineCpuinfo,
kmp_i18n_str_TooManyEntries,
kmp_i18n_str_MissingProcField,
kmp_i18n_str_MissingPhysicalIDField,
kmp_i18n_str_MissingValCpuinfo,
kmp_i18n_str_DuplicateFieldCpuinfo,
kmp_i18n_str_PhysicalIDsNotUnique,
kmp_i18n_str_ApicNotPresent,
kmp_i18n_str_InvalidCpuidInfo,
kmp_i18n_str_OBSOLETE1,
kmp_i18n_str_InconsistentCpuidInfo,
kmp_i18n_str_OutOfHeapMemory,
kmp_i18n_str_MemoryAllocFailed,
kmp_i18n_str_Core,
kmp_i18n_str_Thread,
kmp_i18n_str_Package,
kmp_i18n_str_Node,
kmp_i18n_str_OBSOLETE2,
kmp_i18n_str_DecodingLegacyAPIC,
kmp_i18n_str_OBSOLETE3,
kmp_i18n_str_NotDefined,
kmp_i18n_str_EffectiveSettings,
kmp_i18n_str_UserSettings,
kmp_i18n_str_StorageMapWarning,
kmp_i18n_str_OBSOLETE4,
kmp_i18n_str_OBSOLETE5,
kmp_i18n_str_OBSOLETE6,
kmp_i18n_str_OBSOLETE7,
kmp_i18n_str_OBSOLETE8,
kmp_i18n_str_Decodingx2APIC,
kmp_i18n_str_NoLeaf11Support,
kmp_i18n_str_NoLeaf4Support,
kmp_i18n_str_ThreadIDsNotUnique,
kmp_i18n_str_UsingPthread,
kmp_i18n_str_LegacyApicIDsNotUnique,
kmp_i18n_str_x2ApicIDsNotUnique,
kmp_i18n_str_DisplayEnvBegin,
kmp_i18n_str_DisplayEnvEnd,
kmp_i18n_str_Device,
kmp_i18n_str_Host,
kmp_i18n_str_Tile,
kmp_i18n_str_Tiles,
kmp_i18n_str_Threads,
kmp_i18n_str_Cores,
kmp_i18n_str_Socket,
kmp_i18n_str_Sockets,
kmp_i18n_str_Die,
kmp_i18n_str_Dice,
kmp_i18n_str_Module,
kmp_i18n_str_Modules,
kmp_i18n_str_L1Cache,
kmp_i18n_str_L1Caches,
kmp_i18n_str_L2Cache,
kmp_i18n_str_L2Caches,
kmp_i18n_str_L3Cache,
kmp_i18n_str_L3Caches,
kmp_i18n_str_NumaDomain,
kmp_i18n_str_NumaDomains,
kmp_i18n_str_ProcGroup,
kmp_i18n_str_ProcGroups,
kmp_i18n_str_Unknown,
kmp_i18n_str_NoLeaf31Support,
kmp_i18n_str_HwlocFailed,
kmp_i18n_str_LLCache,
kmp_i18n_str_LLCaches,
kmp_i18n_str_last,
// Set #3, formats.
kmp_i18n_fmt_first = 196608,
kmp_i18n_fmt_Info,
kmp_i18n_fmt_Warning,
kmp_i18n_fmt_Fatal,
kmp_i18n_fmt_SysErr,
kmp_i18n_fmt_Hint,
kmp_i18n_fmt_Pragma,
kmp_i18n_fmt_last,
// Set #4, messages.
kmp_i18n_msg_first = 262144,
kmp_i18n_msg_LibraryIsSerial,
kmp_i18n_msg_CantOpenMessageCatalog,
kmp_i18n_msg_WillUseDefaultMessages,
kmp_i18n_msg_LockIsUninitialized,
kmp_i18n_msg_LockSimpleUsedAsNestable,
kmp_i18n_msg_LockNestableUsedAsSimple,
kmp_i18n_msg_LockIsAlreadyOwned,
kmp_i18n_msg_LockStillOwned,
kmp_i18n_msg_LockUnsettingFree,
kmp_i18n_msg_LockUnsettingSetByAnother,
kmp_i18n_msg_StackOverflow,
kmp_i18n_msg_StackOverlap,
kmp_i18n_msg_AssertionFailure,
kmp_i18n_msg_CantRegisterNewThread,
kmp_i18n_msg_DuplicateLibrary,
kmp_i18n_msg_CantOpenFileForReading,
kmp_i18n_msg_CantGetEnvVar,
kmp_i18n_msg_CantSetEnvVar,
kmp_i18n_msg_CantGetEnvironment,
kmp_i18n_msg_BadBoolValue,
kmp_i18n_msg_SSPNotBuiltIn,
kmp_i18n_msg_SPPSotfTerminateFailed,
kmp_i18n_msg_BufferOverflow,
kmp_i18n_msg_RealTimeSchedNotSupported,
kmp_i18n_msg_RunningAtMaxPriority,
kmp_i18n_msg_CantChangeMonitorPriority,
kmp_i18n_msg_MonitorWillStarve,
kmp_i18n_msg_CantSetMonitorStackSize,
kmp_i18n_msg_CantSetWorkerStackSize,
kmp_i18n_msg_CantInitThreadAttrs,
kmp_i18n_msg_CantDestroyThreadAttrs,
kmp_i18n_msg_CantSetWorkerState,
kmp_i18n_msg_CantSetMonitorState,
kmp_i18n_msg_NoResourcesForWorkerThread,
kmp_i18n_msg_NoResourcesForMonitorThread,
kmp_i18n_msg_CantTerminateWorkerThread,
kmp_i18n_msg_ScheduleKindOutOfRange,
kmp_i18n_msg_UnknownSchedulingType,
kmp_i18n_msg_InvalidValue,
kmp_i18n_msg_SmallValue,
kmp_i18n_msg_LargeValue,
kmp_i18n_msg_StgInvalidValue,
kmp_i18n_msg_BarrReleaseValueInvalid,
kmp_i18n_msg_BarrGatherValueInvalid,
kmp_i18n_msg_OBSOLETE9,
kmp_i18n_msg_ParRangeSyntax,
kmp_i18n_msg_UnbalancedQuotes,
kmp_i18n_msg_EmptyString,
kmp_i18n_msg_LongValue,
kmp_i18n_msg_InvalidClause,
kmp_i18n_msg_EmptyClause,
kmp_i18n_msg_InvalidChunk,
kmp_i18n_msg_LargeChunk,
kmp_i18n_msg_IgnoreChunk,
kmp_i18n_msg_CantGetProcFreq,
kmp_i18n_msg_EnvParallelWarn,
kmp_i18n_msg_AffParamDefined,
kmp_i18n_msg_AffInvalidParam,
kmp_i18n_msg_AffManyParams,
kmp_i18n_msg_AffManyParamsForLogic,
kmp_i18n_msg_AffNoParam,
kmp_i18n_msg_AffNoProcList,
kmp_i18n_msg_AffProcListNoType,
kmp_i18n_msg_AffProcListNotExplicit,
kmp_i18n_msg_AffSyntaxError,
kmp_i18n_msg_AffZeroStride,
kmp_i18n_msg_AffStartGreaterEnd,
kmp_i18n_msg_AffStrideLessZero,
kmp_i18n_msg_AffRangeTooBig,
kmp_i18n_msg_OBSOLETE10,
kmp_i18n_msg_AffNotSupported,
kmp_i18n_msg_OBSOLETE11,
kmp_i18n_msg_GetAffSysCallNotSupported,
kmp_i18n_msg_SetAffSysCallNotSupported,
kmp_i18n_msg_OBSOLETE12,
kmp_i18n_msg_OBSOLETE13,
kmp_i18n_msg_OBSOLETE14,
kmp_i18n_msg_OBSOLETE15,
kmp_i18n_msg_AffCantGetMaskSize,
kmp_i18n_msg_ParseSizeIntWarn,
kmp_i18n_msg_ParseExtraCharsWarn,
kmp_i18n_msg_UnknownForceReduction,
kmp_i18n_msg_TimerUseGettimeofday,
kmp_i18n_msg_TimerNeedMoreParam,
kmp_i18n_msg_TimerInvalidParam,
kmp_i18n_msg_TimerGettimeFailed,
kmp_i18n_msg_TimerUnknownFunction,
kmp_i18n_msg_UnknownSchedTypeDetected,
kmp_i18n_msg_DispatchManyThreads,
kmp_i18n_msg_IttLookupFailed,
kmp_i18n_msg_IttLoadLibFailed,
kmp_i18n_msg_IttAllNotifDisabled,
kmp_i18n_msg_IttObjNotifDisabled,
kmp_i18n_msg_IttMarkNotifDisabled,
kmp_i18n_msg_IttUnloadLibFailed,
kmp_i18n_msg_CantFormThrTeam,
kmp_i18n_msg_ActiveLevelsNegative,
kmp_i18n_msg_ActiveLevelsExceedLimit,
kmp_i18n_msg_SetLibraryIncorrectCall,
kmp_i18n_msg_FatalSysError,
kmp_i18n_msg_OutOfHeapMemory,
kmp_i18n_msg_OBSOLETE16,
kmp_i18n_msg_OBSOLETE17,
kmp_i18n_msg_Using_int_Value,
kmp_i18n_msg_Using_uint_Value,
kmp_i18n_msg_Using_uint64_Value,
kmp_i18n_msg_Using_str_Value,
kmp_i18n_msg_BarrierPatternOverride,
kmp_i18n_msg_MaxValueUsing,
kmp_i18n_msg_MinValueUsing,
kmp_i18n_msg_MemoryAllocFailed,
kmp_i18n_msg_FileNameTooLong,
kmp_i18n_msg_OBSOLETE18,
kmp_i18n_msg_ManyThreadsForTPDirective,
kmp_i18n_msg_AffinityInvalidMask,
kmp_i18n_msg_WrongDefinition,
kmp_i18n_msg_TLSSetValueFailed,
kmp_i18n_msg_TLSOutOfIndexes,
kmp_i18n_msg_OBSOLETE19,
kmp_i18n_msg_CantGetNumAvailCPU,
kmp_i18n_msg_AssumedNumCPU,
kmp_i18n_msg_ErrorInitializeAffinity,
kmp_i18n_msg_AffThreadsMayMigrate,
kmp_i18n_msg_AffIgnoreInvalidProcID,
kmp_i18n_msg_AffNoValidProcID,
kmp_i18n_msg_UsingFlatOS,
kmp_i18n_msg_UsingFlatOSFile,
kmp_i18n_msg_UsingFlatOSFileLine,
kmp_i18n_msg_FileMsgExiting,
kmp_i18n_msg_FileLineMsgExiting,
kmp_i18n_msg_ConstructIdentInvalid,
kmp_i18n_msg_ThreadIdentInvalid,
kmp_i18n_msg_RTLNotInitialized,
kmp_i18n_msg_TPCommonBlocksInconsist,
kmp_i18n_msg_CantSetThreadAffMask,
kmp_i18n_msg_CantSetThreadPriority,
kmp_i18n_msg_CantCreateThread,
kmp_i18n_msg_CantCreateEvent,
kmp_i18n_msg_CantSetEvent,
kmp_i18n_msg_CantCloseHandle,
kmp_i18n_msg_UnknownLibraryType,
kmp_i18n_msg_ReapMonitorError,
kmp_i18n_msg_ReapWorkerError,
kmp_i18n_msg_ChangeThreadAffMaskError,
kmp_i18n_msg_ThreadsMigrate,
kmp_i18n_msg_DecreaseToThreads,
kmp_i18n_msg_IncreaseToThreads,
kmp_i18n_msg_OBSOLETE20,
kmp_i18n_msg_AffCapableUseCpuinfo,
kmp_i18n_msg_AffUseGlobCpuid,
kmp_i18n_msg_AffCapableUseFlat,
kmp_i18n_msg_AffNotCapableUseLocCpuid,
kmp_i18n_msg_AffNotCapableUseCpuinfo,
kmp_i18n_msg_AffFlatTopology,
kmp_i18n_msg_InitOSProcSetRespect,
kmp_i18n_msg_InitOSProcSetNotRespect,
kmp_i18n_msg_AvailableOSProc,
kmp_i18n_msg_Uniform,
kmp_i18n_msg_NonUniform,
kmp_i18n_msg_Topology,
kmp_i18n_msg_OBSOLETE21,
kmp_i18n_msg_OSProcToPackage,
kmp_i18n_msg_OBSOLETE22,
kmp_i18n_msg_OBSOLETE23,
kmp_i18n_msg_OBSOLETE24,
kmp_i18n_msg_OBSOLETE25,
kmp_i18n_msg_OBSOLETE26,
kmp_i18n_msg_OBSOLETE27,
kmp_i18n_msg_OBSOLETE28,
kmp_i18n_msg_OBSOLETE29,
kmp_i18n_msg_OBSOLETE30,
kmp_i18n_msg_OSProcMapToPack,
kmp_i18n_msg_OBSOLETE31,
kmp_i18n_msg_OBSOLETE32,
kmp_i18n_msg_OBSOLETE33,
kmp_i18n_msg_OBSOLETE34,
kmp_i18n_msg_OBSOLETE35,
kmp_i18n_msg_BarriersInDifferentOrder,
kmp_i18n_msg_FunctionError,
kmp_i18n_msg_TopologyExtra,
kmp_i18n_msg_WrongMessageCatalog,
kmp_i18n_msg_StgIgnored,
kmp_i18n_msg_OBSOLETE36,
kmp_i18n_msg_AffTilesNoHWLOC,
kmp_i18n_msg_AffTilesNoTiles,
kmp_i18n_msg_TopologyExtraTile,
kmp_i18n_msg_TopologyExtraNode,
kmp_i18n_msg_TopologyExtraNoTi,
kmp_i18n_msg_OmptOutdatedWorkshare,
kmp_i18n_msg_OmpNoAllocator,
kmp_i18n_msg_TopologyGeneric,
kmp_i18n_msg_AffGranularityBad,
kmp_i18n_msg_TopologyHybrid,
+ kmp_i18n_msg_TopologyHybridCoreEff,
kmp_i18n_msg_CnsBoundToWorksharing,
kmp_i18n_msg_CnsDetectedEnd,
kmp_i18n_msg_CnsIterationRangeTooLarge,
kmp_i18n_msg_CnsLoopIncrZeroProhibited,
kmp_i18n_msg_CnsExpectedEnd,
kmp_i18n_msg_CnsInvalidNesting,
kmp_i18n_msg_CnsMultipleNesting,
kmp_i18n_msg_CnsNestingSameName,
kmp_i18n_msg_CnsNoOrderedClause,
kmp_i18n_msg_CnsNotInTaskConstruct,
kmp_i18n_msg_CnsThreadsAtBarrier,
kmp_i18n_msg_CantConnect,
kmp_i18n_msg_CantConnectUsing,
kmp_i18n_msg_LibNotSupport,
kmp_i18n_msg_LibNotSupportFor,
kmp_i18n_msg_StaticLibNotSupport,
kmp_i18n_msg_OBSOLETE37,
kmp_i18n_msg_IttUnknownGroup,
kmp_i18n_msg_IttEnvVarTooLong,
kmp_i18n_msg_OBSOLETE38,
kmp_i18n_msg_OBSOLETE39,
kmp_i18n_msg_AffInfoStr,
kmp_i18n_msg_AffInfoStrStr,
kmp_i18n_msg_OSProcToPhysicalThreadMap,
kmp_i18n_msg_AffUsingFlatOS,
kmp_i18n_msg_AffParseFilename,
kmp_i18n_msg_MsgExiting,
kmp_i18n_msg_IncompatibleLibrary,
kmp_i18n_msg_IttFunctionError,
kmp_i18n_msg_IttUnknownError,
kmp_i18n_msg_EnvMiddleWarn,
kmp_i18n_msg_CnsLockNotDestroyed,
kmp_i18n_msg_CantLoadBalUsing,
kmp_i18n_msg_AffNotCapableUsePthread,
kmp_i18n_msg_AffUsePthread,
kmp_i18n_msg_OBSOLETE40,
kmp_i18n_msg_OBSOLETE41,
kmp_i18n_msg_OBSOLETE42,
kmp_i18n_msg_OBSOLETE43,
kmp_i18n_msg_NthSyntaxError,
kmp_i18n_msg_NthSpacesNotAllowed,
kmp_i18n_msg_AffStrParseFilename,
kmp_i18n_msg_OBSOLETE44,
kmp_i18n_msg_AffTypeCantUseMultGroups,
kmp_i18n_msg_AffGranCantUseMultGroups,
kmp_i18n_msg_AffWindowsProcGroupMap,
kmp_i18n_msg_AffOSProcToGroup,
kmp_i18n_msg_AffBalancedNotAvail,
kmp_i18n_msg_OBSOLETE45,
kmp_i18n_msg_EnvLockWarn,
kmp_i18n_msg_FutexNotSupported,
kmp_i18n_msg_AffGranUsing,
kmp_i18n_msg_AffHWSubsetInvalid,
kmp_i18n_msg_AffHWSubsetUnsupported,
kmp_i18n_msg_AffHWSubsetManyCores,
kmp_i18n_msg_SyntaxErrorUsing,
kmp_i18n_msg_AdaptiveNotSupported,
kmp_i18n_msg_EnvSyntaxError,
kmp_i18n_msg_EnvSpacesNotAllowed,
kmp_i18n_msg_BoundToOSProcSet,
kmp_i18n_msg_CnsLoopIncrIllegal,
kmp_i18n_msg_NoGompCancellation,
kmp_i18n_msg_AffHWSubsetNonUniform,
kmp_i18n_msg_AffHWSubsetNonThreeLevel,
kmp_i18n_msg_AffGranTopGroup,
kmp_i18n_msg_AffGranGroupType,
kmp_i18n_msg_AffHWSubsetManySockets,
kmp_i18n_msg_AffHWSubsetDeprecated,
kmp_i18n_msg_AffUsingHwloc,
kmp_i18n_msg_AffIgnoringHwloc,
kmp_i18n_msg_AffHwlocErrorOccurred,
kmp_i18n_msg_EnvSerialWarn,
kmp_i18n_msg_EnvMwaitWarn,
kmp_i18n_msg_EnvVarDeprecated,
kmp_i18n_msg_RedMethodNotSupported,
kmp_i18n_msg_AffHWSubsetNoHWLOC,
kmp_i18n_msg_AffHWSubsetManyNodes,
kmp_i18n_msg_AffHWSubsetManyTiles,
kmp_i18n_msg_AffHWSubsetManyProcs,
kmp_i18n_msg_HierSchedInvalid,
kmp_i18n_msg_AffFormatDefault,
kmp_i18n_msg_APIDeprecated,
kmp_i18n_msg_GompFeatureNotSupported,
kmp_i18n_msg_AffHWSubsetManyDies,
kmp_i18n_msg_AffUseGlobCpuidL,
kmp_i18n_msg_AffNotCapableUseLocCpuidL,
kmp_i18n_msg_AffNotUsingHwloc,
kmp_i18n_msg_UserDirectedError,
kmp_i18n_msg_UserDirectedWarning,
kmp_i18n_msg_FailedToCreateTeam,
kmp_i18n_msg_AffHWSubsetManyGeneric,
kmp_i18n_msg_AffHWSubsetNotExistGeneric,
kmp_i18n_msg_AffHWSubsetEqvLayers,
kmp_i18n_msg_AffHWSubsetOutOfOrder,
kmp_i18n_msg_AffEqualTopologyTypes,
kmp_i18n_msg_AffGranTooCoarseProcGroup,
kmp_i18n_msg_StgDeprecatedValue,
+ kmp_i18n_msg_NumTeamsNotPositive,
+ kmp_i18n_msg_AffHWSubsetIncompat,
+ kmp_i18n_msg_AffHWSubsetAttrRepeat,
+ kmp_i18n_msg_AffHWSubsetAttrInvalid,
+ kmp_i18n_msg_AffHWSubsetAllFiltered,
+ kmp_i18n_msg_AffHWSubsetAttrsNonHybrid,
+ kmp_i18n_msg_AffHWSubsetIgnoringAttr,
kmp_i18n_msg_last,
// Set #5, hints.
kmp_i18n_hnt_first = 327680,
kmp_i18n_hnt_SubmitBugReport,
kmp_i18n_hnt_OBSOLETE46,
kmp_i18n_hnt_ChangeStackLimit,
kmp_i18n_hnt_Unset_ALL_THREADS,
kmp_i18n_hnt_Set_ALL_THREADPRIVATE,
kmp_i18n_hnt_PossibleSystemLimitOnThreads,
kmp_i18n_hnt_DuplicateLibrary,
kmp_i18n_hnt_NameComesFrom_CPUINFO_FILE,
kmp_i18n_hnt_NotEnoughMemory,
kmp_i18n_hnt_ValidBoolValues,
kmp_i18n_hnt_BufferOverflow,
kmp_i18n_hnt_RunningAtMaxPriority,
kmp_i18n_hnt_ChangeMonitorStackSize,
kmp_i18n_hnt_ChangeWorkerStackSize,
kmp_i18n_hnt_IncreaseWorkerStackSize,
kmp_i18n_hnt_DecreaseWorkerStackSize,
kmp_i18n_hnt_Decrease_NUM_THREADS,
kmp_i18n_hnt_IncreaseMonitorStackSize,
kmp_i18n_hnt_DecreaseMonitorStackSize,
kmp_i18n_hnt_DecreaseNumberOfThreadsInUse,
kmp_i18n_hnt_DefaultScheduleKindUsed,
kmp_i18n_hnt_GetNewerLibrary,
kmp_i18n_hnt_CheckEnvVar,
kmp_i18n_hnt_OBSOLETE47,
kmp_i18n_hnt_OBSOLETE48,
kmp_i18n_hnt_BadExeFormat,
kmp_i18n_hnt_SystemLimitOnThreads,
kmp_i18n_hnt_SetNewBound,
+ kmp_i18n_hnt_ValidValuesRange,
kmp_i18n_hnt_last,
kmp_i18n_xxx_lastest
}; // enum kmp_i18n_id
typedef enum kmp_i18n_id kmp_i18n_id_t;
// end of file //
diff --git a/lib/libomp/omp-tools.h b/lib/libomp/omp-tools.h
index 1749be7e0508..5092174d66ef 100644
--- a/lib/libomp/omp-tools.h
+++ b/lib/libomp/omp-tools.h
@@ -1,1377 +1,1376 @@
-// $FreeBSD$
/*
* include/omp-tools.h.var
*/
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef __OMPT__
#define __OMPT__
/*****************************************************************************
* system include files
*****************************************************************************/
#include <stdint.h>
#include <stddef.h>
#ifdef DEPRECATION_WARNINGS
# ifdef __cplusplus
# define DEPRECATED_51 [[deprecated("as of 5.1")]]
# else
# define DEPRECATED_51 __attribute__((deprecated("as of 5.1")))
#endif
#else
#define DEPRECATED_51
#endif
/*****************************************************************************
* iteration macros
*****************************************************************************/
#define FOREACH_OMPT_INQUIRY_FN(macro) \
macro (ompt_enumerate_states) \
macro (ompt_enumerate_mutex_impls) \
\
macro (ompt_set_callback) \
macro (ompt_get_callback) \
\
macro (ompt_get_state) \
\
macro (ompt_get_parallel_info) \
macro (ompt_get_task_info) \
macro (ompt_get_task_memory) \
macro (ompt_get_thread_data) \
macro (ompt_get_unique_id) \
macro (ompt_finalize_tool) \
\
macro(ompt_get_num_procs) \
macro(ompt_get_num_places) \
macro(ompt_get_place_proc_ids) \
macro(ompt_get_place_num) \
macro(ompt_get_partition_place_nums) \
macro(ompt_get_proc_id) \
\
macro(ompt_get_target_info) \
macro(ompt_get_num_devices)
#define FOREACH_OMPT_STATE(macro) \
\
/* first available state */ \
macro (ompt_state_undefined, 0x102) /* undefined thread state */ \
\
/* work states (0..15) */ \
macro (ompt_state_work_serial, 0x000) /* working outside parallel */ \
macro (ompt_state_work_parallel, 0x001) /* working within parallel */ \
macro (ompt_state_work_reduction, 0x002) /* performing a reduction */ \
\
/* barrier wait states (16..31) */ \
macro (ompt_state_wait_barrier, 0x010) /* waiting at a barrier */ \
macro (ompt_state_wait_barrier_implicit_parallel, 0x011) \
/* implicit barrier at the end of parallel region */\
macro (ompt_state_wait_barrier_implicit_workshare, 0x012) \
/* implicit barrier at the end of worksharing */ \
macro (ompt_state_wait_barrier_implicit, 0x013) /* implicit barrier */ \
macro (ompt_state_wait_barrier_explicit, 0x014) /* explicit barrier */ \
\
/* task wait states (32..63) */ \
macro (ompt_state_wait_taskwait, 0x020) /* waiting at a taskwait */ \
macro (ompt_state_wait_taskgroup, 0x021) /* waiting at a taskgroup */ \
\
/* mutex wait states (64..127) */ \
macro (ompt_state_wait_mutex, 0x040) \
macro (ompt_state_wait_lock, 0x041) /* waiting for lock */ \
macro (ompt_state_wait_critical, 0x042) /* waiting for critical */ \
macro (ompt_state_wait_atomic, 0x043) /* waiting for atomic */ \
macro (ompt_state_wait_ordered, 0x044) /* waiting for ordered */ \
\
/* target wait states (128..255) */ \
macro (ompt_state_wait_target, 0x080) /* waiting for target region */ \
macro (ompt_state_wait_target_map, 0x081) /* waiting for target data mapping operation */ \
macro (ompt_state_wait_target_update, 0x082) /* waiting for target update operation */ \
\
/* misc (256..511) */ \
macro (ompt_state_idle, 0x100) /* waiting for work */ \
macro (ompt_state_overhead, 0x101) /* overhead excluding wait states */ \
\
/* implementation-specific states (512..) */
#define FOREACH_KMP_MUTEX_IMPL(macro) \
macro (kmp_mutex_impl_none, 0) /* unknown implementation */ \
macro (kmp_mutex_impl_spin, 1) /* based on spin */ \
macro (kmp_mutex_impl_queuing, 2) /* based on some fair policy */ \
macro (kmp_mutex_impl_speculative, 3) /* based on HW-supported speculation */
#define FOREACH_OMPT_EVENT(macro) \
\
/*--- Mandatory Events ---*/ \
macro (ompt_callback_thread_begin, ompt_callback_thread_begin_t, 1) /* thread begin */ \
macro (ompt_callback_thread_end, ompt_callback_thread_end_t, 2) /* thread end */ \
\
macro (ompt_callback_parallel_begin, ompt_callback_parallel_begin_t, 3) /* parallel begin */ \
macro (ompt_callback_parallel_end, ompt_callback_parallel_end_t, 4) /* parallel end */ \
\
macro (ompt_callback_task_create, ompt_callback_task_create_t, 5) /* task begin */ \
macro (ompt_callback_task_schedule, ompt_callback_task_schedule_t, 6) /* task schedule */ \
macro (ompt_callback_implicit_task, ompt_callback_implicit_task_t, 7) /* implicit task */ \
\
macro (ompt_callback_target, ompt_callback_target_t, 8) /* target */ \
macro (ompt_callback_target_data_op, ompt_callback_target_data_op_t, 9) /* target data op */ \
macro (ompt_callback_target_submit, ompt_callback_target_submit_t, 10) /* target submit */ \
\
macro (ompt_callback_control_tool, ompt_callback_control_tool_t, 11) /* control tool */ \
\
macro (ompt_callback_device_initialize, ompt_callback_device_initialize_t, 12) /* device initialize */ \
macro (ompt_callback_device_finalize, ompt_callback_device_finalize_t, 13) /* device finalize */ \
\
macro (ompt_callback_device_load, ompt_callback_device_load_t, 14) /* device load */ \
macro (ompt_callback_device_unload, ompt_callback_device_unload_t, 15) /* device unload */ \
\
/* Optional Events */ \
macro (ompt_callback_sync_region_wait, ompt_callback_sync_region_t, 16) /* sync region wait begin or end */ \
\
macro (ompt_callback_mutex_released, ompt_callback_mutex_t, 17) /* mutex released */ \
\
macro (ompt_callback_dependences, ompt_callback_dependences_t, 18) /* report task dependences */ \
macro (ompt_callback_task_dependence, ompt_callback_task_dependence_t, 19) /* report task dependence */ \
\
macro (ompt_callback_work, ompt_callback_work_t, 20) /* task at work begin or end */ \
\
macro (ompt_callback_masked, ompt_callback_masked_t, 21) /* task at masked begin or end */ \
\
macro (ompt_callback_target_map, ompt_callback_target_map_t, 22) /* target map */ \
\
macro (ompt_callback_sync_region, ompt_callback_sync_region_t, 23) /* sync region begin or end */ \
\
macro (ompt_callback_lock_init, ompt_callback_mutex_acquire_t, 24) /* lock init */ \
macro (ompt_callback_lock_destroy, ompt_callback_mutex_t, 25) /* lock destroy */ \
\
macro (ompt_callback_mutex_acquire, ompt_callback_mutex_acquire_t, 26) /* mutex acquire */ \
macro (ompt_callback_mutex_acquired, ompt_callback_mutex_t, 27) /* mutex acquired */ \
\
macro (ompt_callback_nest_lock, ompt_callback_nest_lock_t, 28) /* nest lock */ \
\
macro (ompt_callback_flush, ompt_callback_flush_t, 29) /* after executing flush */ \
\
macro (ompt_callback_cancel, ompt_callback_cancel_t, 30) /* cancel innermost binding region */ \
\
macro (ompt_callback_reduction, ompt_callback_sync_region_t, 31) /* reduction */ \
\
macro (ompt_callback_dispatch, ompt_callback_dispatch_t, 32) /* dispatch of work */ \
macro (ompt_callback_target_emi, ompt_callback_target_emi_t, 33) /* target */ \
macro (ompt_callback_target_data_op_emi,ompt_callback_target_data_op_emi_t,34) /* target data op */ \
macro (ompt_callback_target_submit_emi, ompt_callback_target_submit_emi_t, 35) /* target submit */ \
macro (ompt_callback_target_map_emi, ompt_callback_target_map_emi_t, 36) /* target map */ \
macro (ompt_callback_error, ompt_callback_error_t, 37) /* error */
/*****************************************************************************
* implementation specific types
*****************************************************************************/
typedef enum kmp_mutex_impl_t {
#define kmp_mutex_impl_macro(impl, code) impl = code,
FOREACH_KMP_MUTEX_IMPL(kmp_mutex_impl_macro)
#undef kmp_mutex_impl_macro
} kmp_mutex_impl_t;
/*****************************************************************************
* definitions generated from spec
*****************************************************************************/
typedef enum ompt_callbacks_t {
ompt_callback_thread_begin = 1,
ompt_callback_thread_end = 2,
ompt_callback_parallel_begin = 3,
ompt_callback_parallel_end = 4,
ompt_callback_task_create = 5,
ompt_callback_task_schedule = 6,
ompt_callback_implicit_task = 7,
ompt_callback_target = 8,
ompt_callback_target_data_op = 9,
ompt_callback_target_submit = 10,
ompt_callback_control_tool = 11,
ompt_callback_device_initialize = 12,
ompt_callback_device_finalize = 13,
ompt_callback_device_load = 14,
ompt_callback_device_unload = 15,
ompt_callback_sync_region_wait = 16,
ompt_callback_mutex_released = 17,
ompt_callback_dependences = 18,
ompt_callback_task_dependence = 19,
ompt_callback_work = 20,
ompt_callback_master DEPRECATED_51 = 21,
ompt_callback_masked = 21,
ompt_callback_target_map = 22,
ompt_callback_sync_region = 23,
ompt_callback_lock_init = 24,
ompt_callback_lock_destroy = 25,
ompt_callback_mutex_acquire = 26,
ompt_callback_mutex_acquired = 27,
ompt_callback_nest_lock = 28,
ompt_callback_flush = 29,
ompt_callback_cancel = 30,
ompt_callback_reduction = 31,
ompt_callback_dispatch = 32,
ompt_callback_target_emi = 33,
ompt_callback_target_data_op_emi = 34,
ompt_callback_target_submit_emi = 35,
ompt_callback_target_map_emi = 36,
ompt_callback_error = 37
} ompt_callbacks_t;
typedef enum ompt_record_t {
ompt_record_ompt = 1,
ompt_record_native = 2,
ompt_record_invalid = 3
} ompt_record_t;
typedef enum ompt_record_native_t {
ompt_record_native_info = 1,
ompt_record_native_event = 2
} ompt_record_native_t;
typedef enum ompt_set_result_t {
ompt_set_error = 0,
ompt_set_never = 1,
ompt_set_impossible = 2,
ompt_set_sometimes = 3,
ompt_set_sometimes_paired = 4,
ompt_set_always = 5
} ompt_set_result_t;
typedef uint64_t ompt_id_t;
typedef uint64_t ompt_device_time_t;
typedef uint64_t ompt_buffer_cursor_t;
typedef enum ompt_thread_t {
ompt_thread_initial = 1,
ompt_thread_worker = 2,
ompt_thread_other = 3,
ompt_thread_unknown = 4
} ompt_thread_t;
typedef enum ompt_scope_endpoint_t {
ompt_scope_begin = 1,
ompt_scope_end = 2,
ompt_scope_beginend = 3
} ompt_scope_endpoint_t;
typedef enum ompt_dispatch_t {
ompt_dispatch_iteration = 1,
ompt_dispatch_section = 2
} ompt_dispatch_t;
typedef enum ompt_sync_region_t {
ompt_sync_region_barrier DEPRECATED_51 = 1,
ompt_sync_region_barrier_implicit DEPRECATED_51 = 2,
ompt_sync_region_barrier_explicit = 3,
ompt_sync_region_barrier_implementation = 4,
ompt_sync_region_taskwait = 5,
ompt_sync_region_taskgroup = 6,
ompt_sync_region_reduction = 7,
ompt_sync_region_barrier_implicit_workshare = 8,
ompt_sync_region_barrier_implicit_parallel = 9,
ompt_sync_region_barrier_teams = 10
} ompt_sync_region_t;
typedef enum ompt_target_data_op_t {
ompt_target_data_alloc = 1,
ompt_target_data_transfer_to_device = 2,
ompt_target_data_transfer_from_device = 3,
ompt_target_data_delete = 4,
ompt_target_data_associate = 5,
ompt_target_data_disassociate = 6,
ompt_target_data_alloc_async = 17,
ompt_target_data_transfer_to_device_async = 18,
ompt_target_data_transfer_from_device_async = 19,
ompt_target_data_delete_async = 20
} ompt_target_data_op_t;
typedef enum ompt_work_t {
ompt_work_loop = 1,
ompt_work_sections = 2,
ompt_work_single_executor = 3,
ompt_work_single_other = 4,
ompt_work_workshare = 5,
ompt_work_distribute = 6,
ompt_work_taskloop = 7,
ompt_work_scope = 8
} ompt_work_t;
typedef enum ompt_mutex_t {
ompt_mutex_lock = 1,
ompt_mutex_test_lock = 2,
ompt_mutex_nest_lock = 3,
ompt_mutex_test_nest_lock = 4,
ompt_mutex_critical = 5,
ompt_mutex_atomic = 6,
ompt_mutex_ordered = 7
} ompt_mutex_t;
typedef enum ompt_native_mon_flag_t {
ompt_native_data_motion_explicit = 0x01,
ompt_native_data_motion_implicit = 0x02,
ompt_native_kernel_invocation = 0x04,
ompt_native_kernel_execution = 0x08,
ompt_native_driver = 0x10,
ompt_native_runtime = 0x20,
ompt_native_overhead = 0x40,
ompt_native_idleness = 0x80
} ompt_native_mon_flag_t;
typedef enum ompt_task_flag_t {
ompt_task_initial = 0x00000001,
ompt_task_implicit = 0x00000002,
ompt_task_explicit = 0x00000004,
ompt_task_target = 0x00000008,
ompt_task_taskwait = 0x00000010,
ompt_task_undeferred = 0x08000000,
ompt_task_untied = 0x10000000,
ompt_task_final = 0x20000000,
ompt_task_mergeable = 0x40000000,
ompt_task_merged = 0x80000000
} ompt_task_flag_t;
typedef enum ompt_task_status_t {
ompt_task_complete = 1,
ompt_task_yield = 2,
ompt_task_cancel = 3,
ompt_task_detach = 4,
ompt_task_early_fulfill = 5,
ompt_task_late_fulfill = 6,
ompt_task_switch = 7,
ompt_taskwait_complete = 8
} ompt_task_status_t;
typedef enum ompt_target_t {
ompt_target = 1,
ompt_target_enter_data = 2,
ompt_target_exit_data = 3,
ompt_target_update = 4,
ompt_target_nowait = 9,
ompt_target_enter_data_nowait = 10,
ompt_target_exit_data_nowait = 11,
ompt_target_update_nowait = 12
} ompt_target_t;
typedef enum ompt_parallel_flag_t {
ompt_parallel_invoker_program = 0x00000001,
ompt_parallel_invoker_runtime = 0x00000002,
ompt_parallel_league = 0x40000000,
ompt_parallel_team = 0x80000000
} ompt_parallel_flag_t;
typedef enum ompt_target_map_flag_t {
ompt_target_map_flag_to = 0x01,
ompt_target_map_flag_from = 0x02,
ompt_target_map_flag_alloc = 0x04,
ompt_target_map_flag_release = 0x08,
ompt_target_map_flag_delete = 0x10,
ompt_target_map_flag_implicit = 0x20
} ompt_target_map_flag_t;
typedef enum ompt_dependence_type_t {
ompt_dependence_type_in = 1,
ompt_dependence_type_out = 2,
ompt_dependence_type_inout = 3,
ompt_dependence_type_mutexinoutset = 4,
ompt_dependence_type_source = 5,
ompt_dependence_type_sink = 6,
ompt_dependence_type_inoutset = 7
} ompt_dependence_type_t;
typedef enum ompt_severity_t {
ompt_warning = 1,
ompt_fatal = 2
} ompt_severity_t;
typedef enum ompt_cancel_flag_t {
ompt_cancel_parallel = 0x01,
ompt_cancel_sections = 0x02,
ompt_cancel_loop = 0x04,
ompt_cancel_taskgroup = 0x08,
ompt_cancel_activated = 0x10,
ompt_cancel_detected = 0x20,
ompt_cancel_discarded_task = 0x40
} ompt_cancel_flag_t;
typedef uint64_t ompt_hwid_t;
typedef uint64_t ompt_wait_id_t;
typedef enum ompt_frame_flag_t {
ompt_frame_runtime = 0x00,
ompt_frame_application = 0x01,
ompt_frame_cfa = 0x10,
ompt_frame_framepointer = 0x20,
ompt_frame_stackaddress = 0x30
} ompt_frame_flag_t;
typedef enum ompt_state_t {
ompt_state_work_serial = 0x000,
ompt_state_work_parallel = 0x001,
ompt_state_work_reduction = 0x002,
ompt_state_wait_barrier DEPRECATED_51 = 0x010,
ompt_state_wait_barrier_implicit_parallel = 0x011,
ompt_state_wait_barrier_implicit_workshare = 0x012,
ompt_state_wait_barrier_implicit DEPRECATED_51 = 0x013,
ompt_state_wait_barrier_explicit = 0x014,
ompt_state_wait_barrier_implementation = 0x015,
ompt_state_wait_barrier_teams = 0x016,
ompt_state_wait_taskwait = 0x020,
ompt_state_wait_taskgroup = 0x021,
ompt_state_wait_mutex = 0x040,
ompt_state_wait_lock = 0x041,
ompt_state_wait_critical = 0x042,
ompt_state_wait_atomic = 0x043,
ompt_state_wait_ordered = 0x044,
ompt_state_wait_target = 0x080,
ompt_state_wait_target_map = 0x081,
ompt_state_wait_target_update = 0x082,
ompt_state_idle = 0x100,
ompt_state_overhead = 0x101,
ompt_state_undefined = 0x102
} ompt_state_t;
typedef uint64_t (*ompt_get_unique_id_t) (void);
typedef uint64_t ompd_size_t;
typedef uint64_t ompd_wait_id_t;
typedef uint64_t ompd_addr_t;
typedef int64_t ompd_word_t;
typedef uint64_t ompd_seg_t;
typedef uint64_t ompd_device_t;
typedef uint64_t ompd_thread_id_t;
typedef enum ompd_scope_t {
ompd_scope_global = 1,
ompd_scope_address_space = 2,
ompd_scope_thread = 3,
ompd_scope_parallel = 4,
ompd_scope_implicit_task = 5,
ompd_scope_task = 6
} ompd_scope_t;
typedef uint64_t ompd_icv_id_t;
typedef enum ompd_rc_t {
ompd_rc_ok = 0,
ompd_rc_unavailable = 1,
ompd_rc_stale_handle = 2,
ompd_rc_bad_input = 3,
ompd_rc_error = 4,
ompd_rc_unsupported = 5,
ompd_rc_needs_state_tracking = 6,
ompd_rc_incompatible = 7,
ompd_rc_device_read_error = 8,
ompd_rc_device_write_error = 9,
ompd_rc_nomem = 10,
ompd_rc_incomplete = 11,
ompd_rc_callback_error = 12
} ompd_rc_t;
typedef void (*ompt_interface_fn_t) (void);
typedef ompt_interface_fn_t (*ompt_function_lookup_t) (
const char *interface_function_name
);
typedef union ompt_data_t {
uint64_t value;
void *ptr;
} ompt_data_t;
typedef struct ompt_frame_t {
ompt_data_t exit_frame;
ompt_data_t enter_frame;
int exit_frame_flags;
int enter_frame_flags;
} ompt_frame_t;
typedef void (*ompt_callback_t) (void);
typedef void ompt_device_t;
typedef void ompt_buffer_t;
typedef void (*ompt_callback_buffer_request_t) (
int device_num,
ompt_buffer_t **buffer,
size_t *bytes
);
typedef void (*ompt_callback_buffer_complete_t) (
int device_num,
ompt_buffer_t *buffer,
size_t bytes,
ompt_buffer_cursor_t begin,
int buffer_owned
);
typedef void (*ompt_finalize_t) (
ompt_data_t *tool_data
);
typedef int (*ompt_initialize_t) (
ompt_function_lookup_t lookup,
int initial_device_num,
ompt_data_t *tool_data
);
typedef struct ompt_start_tool_result_t {
ompt_initialize_t initialize;
ompt_finalize_t finalize;
ompt_data_t tool_data;
} ompt_start_tool_result_t;
typedef struct ompt_record_abstract_t {
ompt_record_native_t rclass;
const char *type;
ompt_device_time_t start_time;
ompt_device_time_t end_time;
ompt_hwid_t hwid;
} ompt_record_abstract_t;
typedef struct ompt_dependence_t {
ompt_data_t variable;
ompt_dependence_type_t dependence_type;
} ompt_dependence_t;
typedef int (*ompt_enumerate_states_t) (
int current_state,
int *next_state,
const char **next_state_name
);
typedef int (*ompt_enumerate_mutex_impls_t) (
int current_impl,
int *next_impl,
const char **next_impl_name
);
typedef ompt_set_result_t (*ompt_set_callback_t) (
ompt_callbacks_t event,
ompt_callback_t callback
);
typedef int (*ompt_get_callback_t) (
ompt_callbacks_t event,
ompt_callback_t *callback
);
typedef ompt_data_t *(*ompt_get_thread_data_t) (void);
typedef int (*ompt_get_num_procs_t) (void);
typedef int (*ompt_get_num_places_t) (void);
typedef int (*ompt_get_place_proc_ids_t) (
int place_num,
int ids_size,
int *ids
);
typedef int (*ompt_get_place_num_t) (void);
typedef int (*ompt_get_partition_place_nums_t) (
int place_nums_size,
int *place_nums
);
typedef int (*ompt_get_proc_id_t) (void);
typedef int (*ompt_get_state_t) (
ompt_wait_id_t *wait_id
);
typedef int (*ompt_get_parallel_info_t) (
int ancestor_level,
ompt_data_t **parallel_data,
int *team_size
);
typedef int (*ompt_get_task_info_t) (
int ancestor_level,
int *flags,
ompt_data_t **task_data,
ompt_frame_t **task_frame,
ompt_data_t **parallel_data,
int *thread_num
);
typedef int (*ompt_get_task_memory_t)(
void **addr,
size_t *size,
int block
);
typedef int (*ompt_get_target_info_t) (
uint64_t *device_num,
ompt_id_t *target_id,
ompt_id_t *host_op_id
);
typedef int (*ompt_get_num_devices_t) (void);
typedef void (*ompt_finalize_tool_t) (void);
typedef int (*ompt_get_device_num_procs_t) (
ompt_device_t *device
);
typedef ompt_device_time_t (*ompt_get_device_time_t) (
ompt_device_t *device
);
typedef double (*ompt_translate_time_t) (
ompt_device_t *device,
ompt_device_time_t time
);
typedef ompt_set_result_t (*ompt_set_trace_ompt_t) (
ompt_device_t *device,
unsigned int enable,
unsigned int etype
);
typedef ompt_set_result_t (*ompt_set_trace_native_t) (
ompt_device_t *device,
int enable,
int flags
);
typedef int (*ompt_start_trace_t) (
ompt_device_t *device,
ompt_callback_buffer_request_t request,
ompt_callback_buffer_complete_t complete
);
typedef int (*ompt_pause_trace_t) (
ompt_device_t *device,
int begin_pause
);
typedef int (*ompt_flush_trace_t) (
ompt_device_t *device
);
typedef int (*ompt_stop_trace_t) (
ompt_device_t *device
);
typedef int (*ompt_advance_buffer_cursor_t) (
ompt_device_t *device,
ompt_buffer_t *buffer,
size_t size,
ompt_buffer_cursor_t current,
ompt_buffer_cursor_t *next
);
typedef ompt_record_t (*ompt_get_record_type_t) (
ompt_buffer_t *buffer,
ompt_buffer_cursor_t current
);
typedef void *(*ompt_get_record_native_t) (
ompt_buffer_t *buffer,
ompt_buffer_cursor_t current,
ompt_id_t *host_op_id
);
typedef ompt_record_abstract_t *
(*ompt_get_record_abstract_t) (
void *native_record
);
typedef void (*ompt_callback_thread_begin_t) (
ompt_thread_t thread_type,
ompt_data_t *thread_data
);
typedef struct ompt_record_thread_begin_t {
ompt_thread_t thread_type;
} ompt_record_thread_begin_t;
typedef void (*ompt_callback_thread_end_t) (
ompt_data_t *thread_data
);
typedef void (*ompt_callback_parallel_begin_t) (
ompt_data_t *encountering_task_data,
const ompt_frame_t *encountering_task_frame,
ompt_data_t *parallel_data,
unsigned int requested_parallelism,
int flags,
const void *codeptr_ra
);
typedef struct ompt_record_parallel_begin_t {
ompt_id_t encountering_task_id;
ompt_id_t parallel_id;
unsigned int requested_parallelism;
int flags;
const void *codeptr_ra;
} ompt_record_parallel_begin_t;
typedef void (*ompt_callback_parallel_end_t) (
ompt_data_t *parallel_data,
ompt_data_t *encountering_task_data,
int flags,
const void *codeptr_ra
);
typedef struct ompt_record_parallel_end_t {
ompt_id_t parallel_id;
ompt_id_t encountering_task_id;
int flags;
const void *codeptr_ra;
} ompt_record_parallel_end_t;
typedef void (*ompt_callback_work_t) (
ompt_work_t wstype,
ompt_scope_endpoint_t endpoint,
ompt_data_t *parallel_data,
ompt_data_t *task_data,
uint64_t count,
const void *codeptr_ra
);
typedef struct ompt_record_work_t {
ompt_work_t wstype;
ompt_scope_endpoint_t endpoint;
ompt_id_t parallel_id;
ompt_id_t task_id;
uint64_t count;
const void *codeptr_ra;
} ompt_record_work_t;
typedef void (*ompt_callback_dispatch_t) (
ompt_data_t *parallel_data,
ompt_data_t *task_data,
ompt_dispatch_t kind,
ompt_data_t instance
);
typedef struct ompt_record_dispatch_t {
ompt_id_t parallel_id;
ompt_id_t task_id;
ompt_dispatch_t kind;
ompt_data_t instance;
} ompt_record_dispatch_t;
typedef void (*ompt_callback_task_create_t) (
ompt_data_t *encountering_task_data,
const ompt_frame_t *encountering_task_frame,
ompt_data_t *new_task_data,
int flags,
int has_dependences,
const void *codeptr_ra
);
typedef struct ompt_record_task_create_t {
ompt_id_t encountering_task_id;
ompt_id_t new_task_id;
int flags;
int has_dependences;
const void *codeptr_ra;
} ompt_record_task_create_t;
typedef void (*ompt_callback_dependences_t) (
ompt_data_t *task_data,
const ompt_dependence_t *deps,
int ndeps
);
typedef struct ompt_record_dependences_t {
ompt_id_t task_id;
ompt_dependence_t dep;
int ndeps;
} ompt_record_dependences_t;
typedef void (*ompt_callback_task_dependence_t) (
ompt_data_t *src_task_data,
ompt_data_t *sink_task_data
);
typedef struct ompt_record_task_dependence_t {
ompt_id_t src_task_id;
ompt_id_t sink_task_id;
} ompt_record_task_dependence_t;
typedef void (*ompt_callback_task_schedule_t) (
ompt_data_t *prior_task_data,
ompt_task_status_t prior_task_status,
ompt_data_t *next_task_data
);
typedef struct ompt_record_task_schedule_t {
ompt_id_t prior_task_id;
ompt_task_status_t prior_task_status;
ompt_id_t next_task_id;
} ompt_record_task_schedule_t;
typedef void (*ompt_callback_implicit_task_t) (
ompt_scope_endpoint_t endpoint,
ompt_data_t *parallel_data,
ompt_data_t *task_data,
unsigned int actual_parallelism,
unsigned int index,
int flags
);
typedef struct ompt_record_implicit_task_t {
ompt_scope_endpoint_t endpoint;
ompt_id_t parallel_id;
ompt_id_t task_id;
unsigned int actual_parallelism;
unsigned int index;
int flags;
} ompt_record_implicit_task_t;
typedef void (*ompt_callback_masked_t) (
ompt_scope_endpoint_t endpoint,
ompt_data_t *parallel_data,
ompt_data_t *task_data,
const void *codeptr_ra
);
typedef ompt_callback_masked_t ompt_callback_master_t DEPRECATED_51;
typedef struct ompt_record_masked_t {
ompt_scope_endpoint_t endpoint;
ompt_id_t parallel_id;
ompt_id_t task_id;
const void *codeptr_ra;
} ompt_record_masked_t;
typedef void (*ompt_callback_sync_region_t) (
ompt_sync_region_t kind,
ompt_scope_endpoint_t endpoint,
ompt_data_t *parallel_data,
ompt_data_t *task_data,
const void *codeptr_ra
);
typedef struct ompt_record_sync_region_t {
ompt_sync_region_t kind;
ompt_scope_endpoint_t endpoint;
ompt_id_t parallel_id;
ompt_id_t task_id;
const void *codeptr_ra;
} ompt_record_sync_region_t;
typedef void (*ompt_callback_mutex_acquire_t) (
ompt_mutex_t kind,
unsigned int hint,
unsigned int impl,
ompt_wait_id_t wait_id,
const void *codeptr_ra
);
typedef struct ompt_record_mutex_acquire_t {
ompt_mutex_t kind;
unsigned int hint;
unsigned int impl;
ompt_wait_id_t wait_id;
const void *codeptr_ra;
} ompt_record_mutex_acquire_t;
typedef void (*ompt_callback_mutex_t) (
ompt_mutex_t kind,
ompt_wait_id_t wait_id,
const void *codeptr_ra
);
typedef struct ompt_record_mutex_t {
ompt_mutex_t kind;
ompt_wait_id_t wait_id;
const void *codeptr_ra;
} ompt_record_mutex_t;
typedef void (*ompt_callback_nest_lock_t) (
ompt_scope_endpoint_t endpoint,
ompt_wait_id_t wait_id,
const void *codeptr_ra
);
typedef struct ompt_record_nest_lock_t {
ompt_scope_endpoint_t endpoint;
ompt_wait_id_t wait_id;
const void *codeptr_ra;
} ompt_record_nest_lock_t;
typedef void (*ompt_callback_flush_t) (
ompt_data_t *thread_data,
const void *codeptr_ra
);
typedef struct ompt_record_flush_t {
const void *codeptr_ra;
} ompt_record_flush_t;
typedef void (*ompt_callback_cancel_t) (
ompt_data_t *task_data,
int flags,
const void *codeptr_ra
);
typedef struct ompt_record_cancel_t {
ompt_id_t task_id;
int flags;
const void *codeptr_ra;
} ompt_record_cancel_t;
typedef void (*ompt_callback_device_initialize_t) (
int device_num,
const char *type,
ompt_device_t *device,
ompt_function_lookup_t lookup,
const char *documentation
);
typedef void (*ompt_callback_device_finalize_t) (
int device_num
);
typedef void (*ompt_callback_device_load_t) (
int device_num,
const char *filename,
int64_t offset_in_file,
void *vma_in_file,
size_t bytes,
void *host_addr,
void *device_addr,
uint64_t module_id
);
typedef void (*ompt_callback_device_unload_t) (
int device_num,
uint64_t module_id
);
typedef void (*ompt_callback_target_data_op_emi_t) (
ompt_scope_endpoint_t endpoint,
ompt_data_t *target_task_data,
ompt_data_t *target_data,
ompt_id_t *host_op_id,
ompt_target_data_op_t optype,
void *src_addr,
int src_device_num,
void *dest_addr,
int dest_device_num,
size_t bytes,
const void *codeptr_ra
);
typedef void (*ompt_callback_target_data_op_t) (
ompt_id_t target_id,
ompt_id_t host_op_id,
ompt_target_data_op_t optype,
void *src_addr,
int src_device_num,
void *dest_addr,
int dest_device_num,
size_t bytes,
const void *codeptr_ra
);
typedef struct ompt_record_target_data_op_t {
ompt_id_t host_op_id;
ompt_target_data_op_t optype;
void *src_addr;
int src_device_num;
void *dest_addr;
int dest_device_num;
size_t bytes;
ompt_device_time_t end_time;
const void *codeptr_ra;
} ompt_record_target_data_op_t;
typedef void (*ompt_callback_target_emi_t) (
ompt_target_t kind,
ompt_scope_endpoint_t endpoint,
int device_num,
ompt_data_t *task_data,
ompt_data_t *target_task_data,
ompt_data_t *target_data,
const void *codeptr_ra
);
typedef void (*ompt_callback_target_t) (
ompt_target_t kind,
ompt_scope_endpoint_t endpoint,
int device_num,
ompt_data_t *task_data,
ompt_id_t target_id,
const void *codeptr_ra
);
typedef struct ompt_record_target_t {
ompt_target_t kind;
ompt_scope_endpoint_t endpoint;
int device_num;
ompt_id_t task_id;
ompt_id_t target_id;
const void *codeptr_ra;
} ompt_record_target_t;
typedef void (*ompt_callback_target_map_emi_t) (
ompt_data_t *target_data,
unsigned int nitems,
void **host_addr,
void **device_addr,
size_t *bytes,
unsigned int *mapping_flags,
const void *codeptr_ra
);
typedef void (*ompt_callback_target_map_t) (
ompt_id_t target_id,
unsigned int nitems,
void **host_addr,
void **device_addr,
size_t *bytes,
unsigned int *mapping_flags,
const void *codeptr_ra
);
typedef struct ompt_record_target_map_t {
ompt_id_t target_id;
unsigned int nitems;
void **host_addr;
void **device_addr;
size_t *bytes;
unsigned int *mapping_flags;
const void *codeptr_ra;
} ompt_record_target_map_t;
typedef void (*ompt_callback_target_submit_emi_t) (
ompt_scope_endpoint_t endpoint,
ompt_data_t *target_data,
ompt_id_t *host_op_id,
unsigned int requested_num_teams
);
typedef void (*ompt_callback_target_submit_t) (
ompt_id_t target_id,
ompt_id_t host_op_id,
unsigned int requested_num_teams
);
typedef struct ompt_record_target_kernel_t {
ompt_id_t host_op_id;
unsigned int requested_num_teams;
unsigned int granted_num_teams;
ompt_device_time_t end_time;
} ompt_record_target_kernel_t;
typedef int (*ompt_callback_control_tool_t) (
uint64_t command,
uint64_t modifier,
void *arg,
const void *codeptr_ra
);
typedef struct ompt_record_control_tool_t {
uint64_t command;
uint64_t modifier;
const void *codeptr_ra;
} ompt_record_control_tool_t;
typedef void (*ompt_callback_error_t) (
ompt_severity_t severity,
const char *message, size_t length,
const void *codeptr_ra
);
typedef struct ompt_record_error_t {
ompt_severity_t severity;
const char *message;
size_t length;
const void *codeptr_ra;
} ompt_record_error_t;
typedef struct ompd_address_t {
ompd_seg_t segment;
ompd_addr_t address;
} ompd_address_t;
typedef struct ompd_frame_info_t {
ompd_address_t frame_address;
ompd_word_t frame_flag;
} ompd_frame_info_t;
typedef struct _ompd_aspace_handle ompd_address_space_handle_t;
typedef struct _ompd_thread_handle ompd_thread_handle_t;
typedef struct _ompd_parallel_handle ompd_parallel_handle_t;
typedef struct _ompd_task_handle ompd_task_handle_t;
typedef struct _ompd_aspace_cont ompd_address_space_context_t;
typedef struct _ompd_thread_cont ompd_thread_context_t;
typedef struct ompd_device_type_sizes_t {
uint8_t sizeof_char;
uint8_t sizeof_short;
uint8_t sizeof_int;
uint8_t sizeof_long;
uint8_t sizeof_long_long;
uint8_t sizeof_pointer;
} ompd_device_type_sizes_t;
void ompd_dll_locations_valid(void);
typedef ompd_rc_t (*ompd_callback_memory_alloc_fn_t)(ompd_size_t nbytes,
void **ptr);
typedef ompd_rc_t (*ompd_callback_memory_free_fn_t)(void *ptr);
typedef ompd_rc_t (*ompd_callback_get_thread_context_for_thread_id_fn_t)(
ompd_address_space_context_t *address_space_context, ompd_thread_id_t kind,
ompd_size_t sizeof_thread_id, const void *thread_id,
ompd_thread_context_t **thread_context);
typedef ompd_rc_t (*ompd_callback_sizeof_fn_t)(
ompd_address_space_context_t *address_space_context,
ompd_device_type_sizes_t *sizes);
typedef ompd_rc_t (*ompd_callback_symbol_addr_fn_t)(
ompd_address_space_context_t *address_space_context,
ompd_thread_context_t *thread_context, const char *symbol_name,
ompd_address_t *symbol_addr, const char *file_name);
typedef ompd_rc_t (*ompd_callback_memory_read_fn_t)(
ompd_address_space_context_t *address_space_context,
ompd_thread_context_t *thread_context, const ompd_address_t *addr,
ompd_size_t nbytes, void *buffer);
typedef ompd_rc_t (*ompd_callback_memory_write_fn_t)(
ompd_address_space_context_t *address_space_context,
ompd_thread_context_t *thread_context, const ompd_address_t *addr,
ompd_size_t nbytes, const void *buffer);
typedef ompd_rc_t (*ompd_callback_device_host_fn_t)(
ompd_address_space_context_t *address_space_context, const void *input,
ompd_size_t unit_size, ompd_size_t count, void *output);
typedef ompd_rc_t (*ompd_callback_print_string_fn_t)(const char *string,
int category);
typedef struct ompd_callbacks_t {
ompd_callback_memory_alloc_fn_t alloc_memory;
ompd_callback_memory_free_fn_t free_memory;
ompd_callback_print_string_fn_t print_string;
ompd_callback_sizeof_fn_t sizeof_type;
ompd_callback_symbol_addr_fn_t symbol_addr_lookup;
ompd_callback_memory_read_fn_t read_memory;
ompd_callback_memory_write_fn_t write_memory;
ompd_callback_memory_read_fn_t read_string;
ompd_callback_device_host_fn_t device_to_host;
ompd_callback_device_host_fn_t host_to_device;
ompd_callback_get_thread_context_for_thread_id_fn_t
get_thread_context_for_thread_id;
} ompd_callbacks_t;
void ompd_bp_parallel_begin(void);
void ompd_bp_parallel_end(void);
void ompd_bp_task_begin(void);
void ompd_bp_task_end(void);
void ompd_bp_thread_begin(void);
void ompd_bp_thread_end(void);
void ompd_bp_device_begin(void);
void ompd_bp_device_end(void);
ompd_rc_t ompd_initialize(ompd_word_t api_version,
const ompd_callbacks_t *callbacks);
ompd_rc_t ompd_get_api_version(ompd_word_t *version);
ompd_rc_t ompd_get_version_string(const char **string);
ompd_rc_t ompd_finalize(void);
ompd_rc_t ompd_process_initialize(ompd_address_space_context_t *context,
ompd_address_space_handle_t **handle);
ompd_rc_t ompd_device_initialize(ompd_address_space_handle_t *process_handle,
ompd_address_space_context_t *device_context,
ompd_device_t kind, ompd_size_t sizeof_id,
void *id,
ompd_address_space_handle_t **device_handle);
ompd_rc_t ompd_rel_address_space_handle(ompd_address_space_handle_t *handle);
ompd_rc_t ompd_get_omp_version(ompd_address_space_handle_t *address_space,
ompd_word_t *omp_version);
ompd_rc_t
ompd_get_omp_version_string(ompd_address_space_handle_t *address_space,
const char **string);
ompd_rc_t ompd_get_thread_in_parallel(ompd_parallel_handle_t *parallel_handle,
int thread_num,
ompd_thread_handle_t **thread_handle);
ompd_rc_t ompd_get_thread_handle(ompd_address_space_handle_t *handle,
ompd_thread_id_t kind,
ompd_size_t sizeof_thread_id,
const void *thread_id,
ompd_thread_handle_t **thread_handle);
ompd_rc_t ompd_rel_thread_handle(ompd_thread_handle_t *thread_handle);
ompd_rc_t ompd_thread_handle_compare(ompd_thread_handle_t *thread_handle_1,
ompd_thread_handle_t *thread_handle_2,
int *cmp_value);
ompd_rc_t ompd_get_thread_id(ompd_thread_handle_t *thread_handle,
ompd_thread_id_t kind,
ompd_size_t sizeof_thread_id, void *thread_id);
ompd_rc_t
ompd_get_curr_parallel_handle(ompd_thread_handle_t *thread_handle,
ompd_parallel_handle_t **parallel_handle);
ompd_rc_t ompd_get_enclosing_parallel_handle(
ompd_parallel_handle_t *parallel_handle,
ompd_parallel_handle_t **enclosing_parallel_handle);
ompd_rc_t
ompd_get_task_parallel_handle(ompd_task_handle_t *task_handle,
ompd_parallel_handle_t **task_parallel_handle);
ompd_rc_t ompd_rel_parallel_handle(ompd_parallel_handle_t *parallel_handle);
ompd_rc_t
ompd_parallel_handle_compare(ompd_parallel_handle_t *parallel_handle_1,
ompd_parallel_handle_t *parallel_handle_2,
int *cmp_value);
ompd_rc_t ompd_get_curr_task_handle(ompd_thread_handle_t *thread_handle,
ompd_task_handle_t **task_handle);
ompd_rc_t
ompd_get_generating_task_handle(ompd_task_handle_t *task_handle,
ompd_task_handle_t **generating_task_handle);
ompd_rc_t
ompd_get_scheduling_task_handle(ompd_task_handle_t *task_handle,
ompd_task_handle_t **scheduling_task_handle);
ompd_rc_t ompd_get_task_in_parallel(ompd_parallel_handle_t *parallel_handle,
int thread_num,
ompd_task_handle_t **task_handle);
ompd_rc_t ompd_rel_task_handle(ompd_task_handle_t *task_handle);
ompd_rc_t ompd_task_handle_compare(ompd_task_handle_t *task_handle_1,
ompd_task_handle_t *task_handle_2,
int *cmp_value);
ompd_rc_t ompd_get_task_function(ompd_task_handle_t *task_handle,
ompd_address_t *entry_point);
ompd_rc_t ompd_get_task_frame(ompd_task_handle_t *task_handle,
ompd_frame_info_t *exit_frame,
ompd_frame_info_t *enter_frame);
ompd_rc_t
ompd_enumerate_states(ompd_address_space_handle_t *address_space_handle,
ompd_word_t current_state, ompd_word_t *next_state,
const char **next_state_name, ompd_word_t *more_enums);
ompd_rc_t ompd_get_state(ompd_thread_handle_t *thread_handle,
ompd_word_t *state, ompd_wait_id_t *wait_id);
ompd_rc_t
ompd_get_display_control_vars(ompd_address_space_handle_t *address_space_handle,
const char *const **control_vars);
ompd_rc_t ompd_rel_display_control_vars(const char *const **control_vars);
ompd_rc_t ompd_enumerate_icvs(ompd_address_space_handle_t *handle,
ompd_icv_id_t current, ompd_icv_id_t *next_id,
const char **next_icv_name,
ompd_scope_t *next_scope, int *more);
ompd_rc_t ompd_get_icv_from_scope(void *handle, ompd_scope_t scope,
ompd_icv_id_t icv_id, ompd_word_t *icv_value);
ompd_rc_t ompd_get_icv_string_from_scope(void *handle, ompd_scope_t scope,
ompd_icv_id_t icv_id,
const char **icv_string);
ompd_rc_t ompd_get_tool_data(void *handle, ompd_scope_t scope,
ompd_word_t *value, ompd_address_t *ptr);
typedef struct ompt_record_ompt_t {
ompt_callbacks_t type;
ompt_device_time_t time;
ompt_id_t thread_id;
ompt_id_t target_id;
union {
ompt_record_thread_begin_t thread_begin;
ompt_record_parallel_begin_t parallel_begin;
ompt_record_parallel_end_t parallel_end;
ompt_record_work_t work;
ompt_record_dispatch_t dispatch;
ompt_record_task_create_t task_create;
ompt_record_dependences_t dependences;
ompt_record_task_dependence_t task_dependence;
ompt_record_task_schedule_t task_schedule;
ompt_record_implicit_task_t implicit_task;
ompt_record_masked_t masked;
ompt_record_sync_region_t sync_region;
ompt_record_mutex_acquire_t mutex_acquire;
ompt_record_mutex_t mutex;
ompt_record_nest_lock_t nest_lock;
ompt_record_flush_t flush;
ompt_record_cancel_t cancel;
ompt_record_target_t target;
ompt_record_target_data_op_t target_data_op;
ompt_record_target_map_t target_map;
ompt_record_target_kernel_t target_kernel;
ompt_record_control_tool_t control_tool;
} record;
} ompt_record_ompt_t;
typedef ompt_record_ompt_t *(*ompt_get_record_ompt_t) (
ompt_buffer_t *buffer,
ompt_buffer_cursor_t current
);
#define ompt_id_none 0
#define ompt_data_none {0}
#define ompt_time_none 0
#define ompt_hwid_none 0
#define ompt_addr_none ~0
#define ompt_mutex_impl_none 0
#define ompt_wait_id_none 0
#define ompd_segment_none 0
#endif /* __OMPT__ */
diff --git a/lib/libomp/omp.h b/lib/libomp/omp.h
index f36a6d6c7de0..64bfae3f9fdc 100644
--- a/lib/libomp/omp.h
+++ b/lib/libomp/omp.h
@@ -1,514 +1,513 @@
-// $FreeBSD$
/*
* include/omp.h.var
*/
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef __OMP_H
# define __OMP_H
# include <stdlib.h>
# include <stdint.h>
# define KMP_VERSION_MAJOR 5
# define KMP_VERSION_MINOR 0
# define KMP_VERSION_BUILD 20140926
# define KMP_BUILD_DATE "No_Timestamp"
# ifdef __cplusplus
extern "C" {
# endif
# define omp_set_affinity_format ompc_set_affinity_format
# define omp_get_affinity_format ompc_get_affinity_format
# define omp_display_affinity ompc_display_affinity
# define omp_capture_affinity ompc_capture_affinity
# if defined(_WIN32)
# define __KAI_KMPC_CONVENTION __cdecl
# ifndef __KMP_IMP
# define __KMP_IMP __declspec(dllimport)
# endif
# else
# define __KAI_KMPC_CONVENTION
# ifndef __KMP_IMP
# define __KMP_IMP
# endif
# endif
/* schedule kind constants */
typedef enum omp_sched_t {
omp_sched_static = 1,
omp_sched_dynamic = 2,
omp_sched_guided = 3,
omp_sched_auto = 4,
omp_sched_monotonic = 0x80000000
} omp_sched_t;
/* set API functions */
extern void __KAI_KMPC_CONVENTION omp_set_num_threads (int);
extern void __KAI_KMPC_CONVENTION omp_set_dynamic (int);
extern void __KAI_KMPC_CONVENTION omp_set_nested (int);
extern void __KAI_KMPC_CONVENTION omp_set_max_active_levels (int);
extern void __KAI_KMPC_CONVENTION omp_set_schedule (omp_sched_t, int);
/* query API functions */
extern int __KAI_KMPC_CONVENTION omp_get_num_threads (void);
extern int __KAI_KMPC_CONVENTION omp_get_dynamic (void);
extern int __KAI_KMPC_CONVENTION omp_get_nested (void);
extern int __KAI_KMPC_CONVENTION omp_get_max_threads (void);
extern int __KAI_KMPC_CONVENTION omp_get_thread_num (void);
extern int __KAI_KMPC_CONVENTION omp_get_num_procs (void);
extern int __KAI_KMPC_CONVENTION omp_in_parallel (void);
extern int __KAI_KMPC_CONVENTION omp_in_final (void);
extern int __KAI_KMPC_CONVENTION omp_get_active_level (void);
extern int __KAI_KMPC_CONVENTION omp_get_level (void);
extern int __KAI_KMPC_CONVENTION omp_get_ancestor_thread_num (int);
extern int __KAI_KMPC_CONVENTION omp_get_team_size (int);
extern int __KAI_KMPC_CONVENTION omp_get_thread_limit (void);
extern int __KAI_KMPC_CONVENTION omp_get_max_active_levels (void);
extern void __KAI_KMPC_CONVENTION omp_get_schedule (omp_sched_t *, int *);
extern int __KAI_KMPC_CONVENTION omp_get_max_task_priority (void);
/* lock API functions */
typedef struct omp_lock_t {
void * _lk;
} omp_lock_t;
extern void __KAI_KMPC_CONVENTION omp_init_lock (omp_lock_t *);
extern void __KAI_KMPC_CONVENTION omp_set_lock (omp_lock_t *);
extern void __KAI_KMPC_CONVENTION omp_unset_lock (omp_lock_t *);
extern void __KAI_KMPC_CONVENTION omp_destroy_lock (omp_lock_t *);
extern int __KAI_KMPC_CONVENTION omp_test_lock (omp_lock_t *);
/* nested lock API functions */
typedef struct omp_nest_lock_t {
void * _lk;
} omp_nest_lock_t;
extern void __KAI_KMPC_CONVENTION omp_init_nest_lock (omp_nest_lock_t *);
extern void __KAI_KMPC_CONVENTION omp_set_nest_lock (omp_nest_lock_t *);
extern void __KAI_KMPC_CONVENTION omp_unset_nest_lock (omp_nest_lock_t *);
extern void __KAI_KMPC_CONVENTION omp_destroy_nest_lock (omp_nest_lock_t *);
extern int __KAI_KMPC_CONVENTION omp_test_nest_lock (omp_nest_lock_t *);
/* OpenMP 5.0 Synchronization hints*/
typedef enum omp_sync_hint_t {
omp_sync_hint_none = 0,
omp_lock_hint_none = omp_sync_hint_none,
omp_sync_hint_uncontended = 1,
omp_lock_hint_uncontended = omp_sync_hint_uncontended,
omp_sync_hint_contended = (1<<1),
omp_lock_hint_contended = omp_sync_hint_contended,
omp_sync_hint_nonspeculative = (1<<2),
omp_lock_hint_nonspeculative = omp_sync_hint_nonspeculative,
omp_sync_hint_speculative = (1<<3),
omp_lock_hint_speculative = omp_sync_hint_speculative,
kmp_lock_hint_hle = (1<<16),
kmp_lock_hint_rtm = (1<<17),
kmp_lock_hint_adaptive = (1<<18)
} omp_sync_hint_t;
/* lock hint type for dynamic user lock */
typedef omp_sync_hint_t omp_lock_hint_t;
/* hinted lock initializers */
extern void __KAI_KMPC_CONVENTION omp_init_lock_with_hint(omp_lock_t *, omp_lock_hint_t);
extern void __KAI_KMPC_CONVENTION omp_init_nest_lock_with_hint(omp_nest_lock_t *, omp_lock_hint_t);
/* time API functions */
extern double __KAI_KMPC_CONVENTION omp_get_wtime (void);
extern double __KAI_KMPC_CONVENTION omp_get_wtick (void);
/* OpenMP 4.0 */
extern int __KAI_KMPC_CONVENTION omp_get_default_device (void);
extern void __KAI_KMPC_CONVENTION omp_set_default_device (int);
extern int __KAI_KMPC_CONVENTION omp_is_initial_device (void);
extern int __KAI_KMPC_CONVENTION omp_get_num_devices (void);
extern int __KAI_KMPC_CONVENTION omp_get_num_teams (void);
extern int __KAI_KMPC_CONVENTION omp_get_team_num (void);
extern int __KAI_KMPC_CONVENTION omp_get_cancellation (void);
/* OpenMP 4.5 */
extern int __KAI_KMPC_CONVENTION omp_get_initial_device (void);
extern void* __KAI_KMPC_CONVENTION omp_target_alloc(size_t, int);
extern void __KAI_KMPC_CONVENTION omp_target_free(void *, int);
extern int __KAI_KMPC_CONVENTION omp_target_is_present(const void *, int);
extern int __KAI_KMPC_CONVENTION omp_target_memcpy(void *, const void *, size_t, size_t, size_t, int, int);
extern int __KAI_KMPC_CONVENTION omp_target_memcpy_rect(void *, const void *, size_t, int, const size_t *,
const size_t *, const size_t *, const size_t *, const size_t *, int, int);
extern int __KAI_KMPC_CONVENTION omp_target_associate_ptr(const void *, const void *, size_t, size_t, int);
extern int __KAI_KMPC_CONVENTION omp_target_disassociate_ptr(const void *, int);
/* OpenMP 5.0 */
extern int __KAI_KMPC_CONVENTION omp_get_device_num (void);
typedef void * omp_depend_t;
/* OpenMP 5.1 interop */
typedef intptr_t omp_intptr_t;
/* 0..omp_get_num_interop_properties()-1 are reserved for implementation-defined properties */
typedef enum omp_interop_property {
omp_ipr_fr_id = -1,
omp_ipr_fr_name = -2,
omp_ipr_vendor = -3,
omp_ipr_vendor_name = -4,
omp_ipr_device_num = -5,
omp_ipr_platform = -6,
omp_ipr_device = -7,
omp_ipr_device_context = -8,
omp_ipr_targetsync = -9,
omp_ipr_first = -9
} omp_interop_property_t;
#define omp_interop_none 0
typedef enum omp_interop_rc {
omp_irc_no_value = 1,
omp_irc_success = 0,
omp_irc_empty = -1,
omp_irc_out_of_range = -2,
omp_irc_type_int = -3,
omp_irc_type_ptr = -4,
omp_irc_type_str = -5,
omp_irc_other = -6
} omp_interop_rc_t;
typedef enum omp_interop_fr {
omp_ifr_cuda = 1,
omp_ifr_cuda_driver = 2,
omp_ifr_opencl = 3,
omp_ifr_sycl = 4,
omp_ifr_hip = 5,
omp_ifr_level_zero = 6,
omp_ifr_last = 7
} omp_interop_fr_t;
typedef void * omp_interop_t;
/*!
* The `omp_get_num_interop_properties` routine retrieves the number of implementation-defined properties available for an `omp_interop_t` object.
*/
extern int __KAI_KMPC_CONVENTION omp_get_num_interop_properties(const omp_interop_t);
/*!
* The `omp_get_interop_int` routine retrieves an integer property from an `omp_interop_t` object.
*/
extern omp_intptr_t __KAI_KMPC_CONVENTION omp_get_interop_int(const omp_interop_t, omp_interop_property_t, int *);
/*!
* The `omp_get_interop_ptr` routine retrieves a pointer property from an `omp_interop_t` object.
*/
extern void * __KAI_KMPC_CONVENTION omp_get_interop_ptr(const omp_interop_t, omp_interop_property_t, int *);
/*!
* The `omp_get_interop_str` routine retrieves a string property from an `omp_interop_t` object.
*/
extern const char * __KAI_KMPC_CONVENTION omp_get_interop_str(const omp_interop_t, omp_interop_property_t, int *);
/*!
* The `omp_get_interop_name` routine retrieves a property name from an `omp_interop_t` object.
*/
extern const char * __KAI_KMPC_CONVENTION omp_get_interop_name(const omp_interop_t, omp_interop_property_t);
/*!
* The `omp_get_interop_type_desc` routine retrieves a description of the type of a property associated with an `omp_interop_t` object.
*/
extern const char * __KAI_KMPC_CONVENTION omp_get_interop_type_desc(const omp_interop_t, omp_interop_property_t);
/*!
* The `omp_get_interop_rc_desc` routine retrieves a description of the return code associated with an `omp_interop_t` object.
*/
extern const char * __KAI_KMPC_CONVENTION omp_get_interop_rc_desc(const omp_interop_t, omp_interop_rc_t);
/* OpenMP 5.1 device memory routines */
/*!
* The `omp_target_memcpy_async` routine asynchronously performs a copy between any combination of host and device pointers.
*/
extern int __KAI_KMPC_CONVENTION omp_target_memcpy_async(void *, const void *, size_t, size_t, size_t, int,
int, int, omp_depend_t *);
/*!
* The `omp_target_memcpy_rect_async` routine asynchronously performs a copy between any combination of host and device pointers.
*/
extern int __KAI_KMPC_CONVENTION omp_target_memcpy_rect_async(void *, const void *, size_t, int, const size_t *,
const size_t *, const size_t *, const size_t *, const size_t *, int, int,
int, omp_depend_t *);
/*!
* The `omp_get_mapped_ptr` routine returns the device pointer that is associated with a host pointer for a given device.
*/
extern void * __KAI_KMPC_CONVENTION omp_get_mapped_ptr(const void *, int);
extern int __KAI_KMPC_CONVENTION omp_target_is_accessible(const void *, size_t, int);
/* kmp API functions */
extern int __KAI_KMPC_CONVENTION kmp_get_stacksize (void);
extern void __KAI_KMPC_CONVENTION kmp_set_stacksize (int);
extern size_t __KAI_KMPC_CONVENTION kmp_get_stacksize_s (void);
extern void __KAI_KMPC_CONVENTION kmp_set_stacksize_s (size_t);
extern int __KAI_KMPC_CONVENTION kmp_get_blocktime (void);
extern int __KAI_KMPC_CONVENTION kmp_get_library (void);
extern void __KAI_KMPC_CONVENTION kmp_set_blocktime (int);
extern void __KAI_KMPC_CONVENTION kmp_set_library (int);
extern void __KAI_KMPC_CONVENTION kmp_set_library_serial (void);
extern void __KAI_KMPC_CONVENTION kmp_set_library_turnaround (void);
extern void __KAI_KMPC_CONVENTION kmp_set_library_throughput (void);
extern void __KAI_KMPC_CONVENTION kmp_set_defaults (char const *);
extern void __KAI_KMPC_CONVENTION kmp_set_disp_num_buffers (int);
/* Intel affinity API */
typedef void * kmp_affinity_mask_t;
extern int __KAI_KMPC_CONVENTION kmp_set_affinity (kmp_affinity_mask_t *);
extern int __KAI_KMPC_CONVENTION kmp_get_affinity (kmp_affinity_mask_t *);
extern int __KAI_KMPC_CONVENTION kmp_get_affinity_max_proc (void);
extern void __KAI_KMPC_CONVENTION kmp_create_affinity_mask (kmp_affinity_mask_t *);
extern void __KAI_KMPC_CONVENTION kmp_destroy_affinity_mask (kmp_affinity_mask_t *);
extern int __KAI_KMPC_CONVENTION kmp_set_affinity_mask_proc (int, kmp_affinity_mask_t *);
extern int __KAI_KMPC_CONVENTION kmp_unset_affinity_mask_proc (int, kmp_affinity_mask_t *);
extern int __KAI_KMPC_CONVENTION kmp_get_affinity_mask_proc (int, kmp_affinity_mask_t *);
/* OpenMP 4.0 affinity API */
typedef enum omp_proc_bind_t {
omp_proc_bind_false = 0,
omp_proc_bind_true = 1,
omp_proc_bind_master = 2,
omp_proc_bind_close = 3,
omp_proc_bind_spread = 4
} omp_proc_bind_t;
extern omp_proc_bind_t __KAI_KMPC_CONVENTION omp_get_proc_bind (void);
/* OpenMP 4.5 affinity API */
extern int __KAI_KMPC_CONVENTION omp_get_num_places (void);
extern int __KAI_KMPC_CONVENTION omp_get_place_num_procs (int);
extern void __KAI_KMPC_CONVENTION omp_get_place_proc_ids (int, int *);
extern int __KAI_KMPC_CONVENTION omp_get_place_num (void);
extern int __KAI_KMPC_CONVENTION omp_get_partition_num_places (void);
extern void __KAI_KMPC_CONVENTION omp_get_partition_place_nums (int *);
extern void * __KAI_KMPC_CONVENTION kmp_malloc (size_t);
extern void * __KAI_KMPC_CONVENTION kmp_aligned_malloc (size_t, size_t);
extern void * __KAI_KMPC_CONVENTION kmp_calloc (size_t, size_t);
extern void * __KAI_KMPC_CONVENTION kmp_realloc (void *, size_t);
extern void __KAI_KMPC_CONVENTION kmp_free (void *);
extern void __KAI_KMPC_CONVENTION kmp_set_warnings_on(void);
extern void __KAI_KMPC_CONVENTION kmp_set_warnings_off(void);
/* OpenMP 5.0 Tool Control */
typedef enum omp_control_tool_result_t {
omp_control_tool_notool = -2,
omp_control_tool_nocallback = -1,
omp_control_tool_success = 0,
omp_control_tool_ignored = 1
} omp_control_tool_result_t;
typedef enum omp_control_tool_t {
omp_control_tool_start = 1,
omp_control_tool_pause = 2,
omp_control_tool_flush = 3,
omp_control_tool_end = 4
} omp_control_tool_t;
extern int __KAI_KMPC_CONVENTION omp_control_tool(int, int, void*);
/* OpenMP 5.0 Memory Management */
typedef uintptr_t omp_uintptr_t;
typedef enum {
omp_atk_sync_hint = 1,
omp_atk_alignment = 2,
omp_atk_access = 3,
omp_atk_pool_size = 4,
omp_atk_fallback = 5,
omp_atk_fb_data = 6,
omp_atk_pinned = 7,
omp_atk_partition = 8
} omp_alloctrait_key_t;
typedef enum {
omp_atv_false = 0,
omp_atv_true = 1,
omp_atv_contended = 3,
omp_atv_uncontended = 4,
omp_atv_serialized = 5,
omp_atv_sequential = omp_atv_serialized, // (deprecated)
omp_atv_private = 6,
omp_atv_all = 7,
omp_atv_thread = 8,
omp_atv_pteam = 9,
omp_atv_cgroup = 10,
omp_atv_default_mem_fb = 11,
omp_atv_null_fb = 12,
omp_atv_abort_fb = 13,
omp_atv_allocator_fb = 14,
omp_atv_environment = 15,
omp_atv_nearest = 16,
omp_atv_blocked = 17,
omp_atv_interleaved = 18
} omp_alloctrait_value_t;
#define omp_atv_default ((omp_uintptr_t)-1)
typedef struct {
omp_alloctrait_key_t key;
omp_uintptr_t value;
} omp_alloctrait_t;
# if defined(_WIN32)
// On Windows cl and icl do not support 64-bit enum, let's use integer then.
typedef omp_uintptr_t omp_allocator_handle_t;
extern __KMP_IMP omp_allocator_handle_t const omp_null_allocator;
extern __KMP_IMP omp_allocator_handle_t const omp_default_mem_alloc;
extern __KMP_IMP omp_allocator_handle_t const omp_large_cap_mem_alloc;
extern __KMP_IMP omp_allocator_handle_t const omp_const_mem_alloc;
extern __KMP_IMP omp_allocator_handle_t const omp_high_bw_mem_alloc;
extern __KMP_IMP omp_allocator_handle_t const omp_low_lat_mem_alloc;
extern __KMP_IMP omp_allocator_handle_t const omp_cgroup_mem_alloc;
extern __KMP_IMP omp_allocator_handle_t const omp_pteam_mem_alloc;
extern __KMP_IMP omp_allocator_handle_t const omp_thread_mem_alloc;
/* Preview of target memory support */
extern __KMP_IMP omp_allocator_handle_t const llvm_omp_target_host_mem_alloc;
extern __KMP_IMP omp_allocator_handle_t const llvm_omp_target_shared_mem_alloc;
extern __KMP_IMP omp_allocator_handle_t const llvm_omp_target_device_mem_alloc;
typedef omp_uintptr_t omp_memspace_handle_t;
extern __KMP_IMP omp_memspace_handle_t const omp_default_mem_space;
extern __KMP_IMP omp_memspace_handle_t const omp_large_cap_mem_space;
extern __KMP_IMP omp_memspace_handle_t const omp_const_mem_space;
extern __KMP_IMP omp_memspace_handle_t const omp_high_bw_mem_space;
extern __KMP_IMP omp_memspace_handle_t const omp_low_lat_mem_space;
/* Preview of target memory support */
extern __KMP_IMP omp_memspace_handle_t const llvm_omp_target_host_mem_space;
extern __KMP_IMP omp_memspace_handle_t const llvm_omp_target_shared_mem_space;
extern __KMP_IMP omp_memspace_handle_t const llvm_omp_target_device_mem_space;
# else
# if __cplusplus >= 201103
typedef enum omp_allocator_handle_t : omp_uintptr_t
# else
typedef enum omp_allocator_handle_t
# endif
{
omp_null_allocator = 0,
omp_default_mem_alloc = 1,
omp_large_cap_mem_alloc = 2,
omp_const_mem_alloc = 3,
omp_high_bw_mem_alloc = 4,
omp_low_lat_mem_alloc = 5,
omp_cgroup_mem_alloc = 6,
omp_pteam_mem_alloc = 7,
omp_thread_mem_alloc = 8,
/* Preview of target memory support */
llvm_omp_target_host_mem_alloc = 100,
llvm_omp_target_shared_mem_alloc = 101,
llvm_omp_target_device_mem_alloc = 102,
KMP_ALLOCATOR_MAX_HANDLE = UINTPTR_MAX
} omp_allocator_handle_t;
# if __cplusplus >= 201103
typedef enum omp_memspace_handle_t : omp_uintptr_t
# else
typedef enum omp_memspace_handle_t
# endif
{
omp_default_mem_space = 0,
omp_large_cap_mem_space = 1,
omp_const_mem_space = 2,
omp_high_bw_mem_space = 3,
omp_low_lat_mem_space = 4,
/* Preview of target memory support */
llvm_omp_target_host_mem_space = 100,
llvm_omp_target_shared_mem_space = 101,
llvm_omp_target_device_mem_space = 102,
KMP_MEMSPACE_MAX_HANDLE = UINTPTR_MAX
} omp_memspace_handle_t;
# endif
extern omp_allocator_handle_t __KAI_KMPC_CONVENTION omp_init_allocator(omp_memspace_handle_t m,
int ntraits, omp_alloctrait_t traits[]);
extern void __KAI_KMPC_CONVENTION omp_destroy_allocator(omp_allocator_handle_t allocator);
extern void __KAI_KMPC_CONVENTION omp_set_default_allocator(omp_allocator_handle_t a);
extern omp_allocator_handle_t __KAI_KMPC_CONVENTION omp_get_default_allocator(void);
# ifdef __cplusplus
extern void *__KAI_KMPC_CONVENTION omp_alloc(size_t size, omp_allocator_handle_t a = omp_null_allocator);
extern void *__KAI_KMPC_CONVENTION omp_aligned_alloc(size_t align, size_t size,
omp_allocator_handle_t a = omp_null_allocator);
extern void *__KAI_KMPC_CONVENTION omp_calloc(size_t nmemb, size_t size,
omp_allocator_handle_t a = omp_null_allocator);
extern void *__KAI_KMPC_CONVENTION omp_aligned_calloc(size_t align, size_t nmemb, size_t size,
omp_allocator_handle_t a = omp_null_allocator);
extern void *__KAI_KMPC_CONVENTION omp_realloc(void *ptr, size_t size,
omp_allocator_handle_t allocator = omp_null_allocator,
omp_allocator_handle_t free_allocator = omp_null_allocator);
extern void __KAI_KMPC_CONVENTION omp_free(void * ptr, omp_allocator_handle_t a = omp_null_allocator);
# else
extern void *__KAI_KMPC_CONVENTION omp_alloc(size_t size, omp_allocator_handle_t a);
extern void *__KAI_KMPC_CONVENTION omp_aligned_alloc(size_t align, size_t size,
omp_allocator_handle_t a);
extern void *__KAI_KMPC_CONVENTION omp_calloc(size_t nmemb, size_t size, omp_allocator_handle_t a);
extern void *__KAI_KMPC_CONVENTION omp_aligned_calloc(size_t align, size_t nmemb, size_t size,
omp_allocator_handle_t a);
extern void *__KAI_KMPC_CONVENTION omp_realloc(void *ptr, size_t size, omp_allocator_handle_t allocator,
omp_allocator_handle_t free_allocator);
extern void __KAI_KMPC_CONVENTION omp_free(void *ptr, omp_allocator_handle_t a);
# endif
/* OpenMP 5.0 Affinity Format */
extern void __KAI_KMPC_CONVENTION omp_set_affinity_format(char const *);
extern size_t __KAI_KMPC_CONVENTION omp_get_affinity_format(char *, size_t);
extern void __KAI_KMPC_CONVENTION omp_display_affinity(char const *);
extern size_t __KAI_KMPC_CONVENTION omp_capture_affinity(char *, size_t, char const *);
/* OpenMP 5.0 events */
# if defined(_WIN32)
// On Windows cl and icl do not support 64-bit enum, let's use integer then.
typedef omp_uintptr_t omp_event_handle_t;
# else
typedef enum omp_event_handle_t { KMP_EVENT_MAX_HANDLE = UINTPTR_MAX } omp_event_handle_t;
# endif
extern void __KAI_KMPC_CONVENTION omp_fulfill_event ( omp_event_handle_t event );
/* OpenMP 5.0 Pause Resources */
typedef enum omp_pause_resource_t {
omp_pause_resume = 0,
omp_pause_soft = 1,
omp_pause_hard = 2
} omp_pause_resource_t;
extern int __KAI_KMPC_CONVENTION omp_pause_resource(omp_pause_resource_t, int);
extern int __KAI_KMPC_CONVENTION omp_pause_resource_all(omp_pause_resource_t);
extern int __KAI_KMPC_CONVENTION omp_get_supported_active_levels(void);
/* OpenMP 5.1 */
extern void __KAI_KMPC_CONVENTION omp_set_num_teams(int num_teams);
extern int __KAI_KMPC_CONVENTION omp_get_max_teams(void);
extern void __KAI_KMPC_CONVENTION omp_set_teams_thread_limit(int limit);
extern int __KAI_KMPC_CONVENTION omp_get_teams_thread_limit(void);
/* OpenMP 5.1 Display Environment */
extern void omp_display_env(int verbose);
# if defined(_OPENMP) && _OPENMP >= 201811
#pragma omp begin declare variant match(device={kind(host)})
static inline int omp_is_initial_device(void) { return 1; }
#pragma omp end declare variant
#pragma omp begin declare variant match(device={kind(nohost)})
static inline int omp_is_initial_device(void) { return 0; }
#pragma omp end declare variant
# endif
# undef __KAI_KMPC_CONVENTION
# undef __KMP_IMP
/* Warning:
The following typedefs are not standard, deprecated and will be removed in a future release.
*/
typedef int omp_int_t;
typedef double omp_wtime_t;
# ifdef __cplusplus
}
# endif
#endif /* __OMP_H */

File Metadata

Mime Type
application/octet-stream
Expires
Fri, May 3, 1:52 AM (2 d)
Storage Engine
chunks
Storage Format
Chunks
Storage Handle
ewgCEBXgJzk7
Default Alt Text
(4 MB)

Event Timeline