src/hotspot/os/bsd/memMapPrinter_macosx.cpp - openjdk/jdk25u - Git at Google


            
            /*

            
             * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved.

            
             * Copyright (c) 2023, 2024, Red Hat, Inc. and/or its affiliates.

            
             * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

            
             *

            
             * This code is free software; you can redistribute it and/or modify it

            
             * under the terms of the GNU General Public License version 2 only, as

            
             * published by the Free Software Foundation.

            
             *

            
             * This code is distributed in the hope that it will be useful, but WITHOUT

            
             * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

            
             * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

            
             * version 2 for more details (a copy is included in the LICENSE file that

            
             * accompanied this code).

            
             *

            
             * You should have received a copy of the GNU General Public License version

            
             * 2 along with this work; if not, write to the Free Software Foundation,

            
             * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

            
             *

            
             * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

            
             * or visit www.oracle.com if you need additional information or have any

            
             * questions.

            
             *

            
             */


            #if defined(__APPLE__)


            #include "nmt/memMapPrinter.hpp"

            
            #include "runtime/os.hpp"

            
            #include "utilities/align.hpp"

            
            #include "utilities/globalDefinitions.hpp"

            
            #include "utilities/ostream.hpp"

            
            #include "utilities/powerOfTwo.hpp"


            #include <limits.h>

            
            #include <stdio.h>

            
            #include <stdlib.h>

            
            #include <libproc.h>

            
            #include <unistd.h>


            #include <mach/vm_inherit.h>

            
            #include <mach/vm_prot.h>

            
            #include <mach/mach_vm.h>


            // maximum number of mapping records returned

            
            static const int MAX_REGIONS_RETURNED = 1000000;


            // ::mmap() on MacOS is a layer on top of Mach system calls, and will allocate in 128MB chunks.

            
            // This code will coalesce a series of identical 128GB chunks (maybe followed by one smaller chunk

            
            // with identical flags) into one.

            
            // Unfortunately, two or more identically allocated contiguous sections will appear as one, if the

            
            // first section is size 128MB.  vmmap(1) has the same issue.

            
            static const int MACOS_PARTIAL_ALLOCATION_SIZE = 128 * M;


            class MappingInfo {

            
              proc_regioninfo _rinfo;

            
            public:

            
              const char* _address;

            
              size_t _size;

            
              stringStream _share_buffer;

            
              stringStream _type_buffer;

            
              stringStream _protect_buffer;

            
              stringStream _file_name;

            
              const char* _tag_text;


              MappingInfo() : _address(nullptr), _size(0), _tag_text(nullptr) {}


              void reset() {

            
                _share_buffer.reset();

            
                _protect_buffer.reset();

            
                _type_buffer.reset();

            
                _file_name.reset();

            
                _tag_text = nullptr;

            
              }


              bool canCombine(const proc_regionwithpathinfo& mem_info) {

            
                const proc_regioninfo& n = mem_info.prp_prinfo;

            
                bool cc = _rinfo.pri_size == MACOS_PARTIAL_ALLOCATION_SIZE

            
                          && n.pri_address == (_rinfo.pri_address + _size)

            
                          && n.pri_protection == _rinfo.pri_protection

            
                          && n.pri_max_protection == _rinfo.pri_max_protection

            
                          && n.pri_user_tag == _rinfo.pri_user_tag

            
                          && n.pri_share_mode == _rinfo.pri_share_mode

            
                          && n.pri_offset == 0;

            
                return cc;

            
              }


              void combineWithFollowing(const proc_regionwithpathinfo& mem_info) {

            
                _size += mem_info.prp_prinfo.pri_size;

            
              }


              void process(const proc_regionwithpathinfo& mem_info) {

            
                reset();


                _rinfo = mem_info.prp_prinfo;


                _address = (const char*) _rinfo.pri_address;

            
                _size = _rinfo.pri_size;


                if (mem_info.prp_vip.vip_path[0] != '\0') {

            
                  _file_name.print_raw(mem_info.prp_vip.vip_path);

            
                }

            
                // proc_regionfilename() seems to give bad results, so we don't try to use it here.


                char prot[4];

            
                char maxprot[4];

            
                rwbits(_rinfo.pri_protection, prot);

            
                rwbits(_rinfo.pri_max_protection, maxprot);

            
                _protect_buffer.print("%s/%s", prot, maxprot);


                get_share_mode(_share_buffer, _rinfo);

            
                _tag_text = tagToStr(_rinfo.pri_user_tag);

            
              }


              static void get_share_mode(outputStream& out, const proc_regioninfo& rinfo) {

            
                static const char* share_strings[] = {

            
                  "cow", "pvt", "---", "shr", "tsh", "p/a", "s/a", "lpg"

            
                };

            
                assert(SM_COW == 1 && SM_LARGE_PAGE == (sizeof(share_strings)/sizeof(share_strings[0])), "share_mode contants are out of range");  // the +1 offset is intentional; see below

            
                const bool valid_share_mode = rinfo.pri_share_mode >= SM_COW && rinfo.pri_share_mode <= SM_LARGE_PAGE;

            
                if (valid_share_mode) {

            
                  int share_mode = rinfo.pri_share_mode;

            
                  out.print_raw(share_strings[share_mode - 1]);

            
                } else {

            
                  out.print_cr("invalid pri_share_mode (%d)", rinfo.pri_share_mode);

            
                  assert(valid_share_mode, "invalid pri_share_mode (%d)", rinfo.pri_share_mode);

            
                }

            
              }


            #define X1(TAG, DESCR) X2(TAG, DESCR)

            
            #define X2(TAG, DESCRIPTION) case VM_MEMORY_ ## TAG: return # DESCRIPTION;

            
              static const char* tagToStr(uint32_t user_tag) {

            
                switch (user_tag) {

            
                  case 0:

            
                    return 0;

            
                  X1(MALLOC, malloc);

            
                  X1(MALLOC_SMALL, malloc_small);

            
                  X1(MALLOC_LARGE, malloc_large);

            
                  X1(MALLOC_HUGE, malloc_huge);

            
                  X1(SBRK, sbrk);

            
                  X1(REALLOC, realloc);

            
                  X1(MALLOC_TINY, malloc_tiny);

            
                  X1(MALLOC_LARGE_REUSABLE, malloc_large_reusable);

            
                  X1(MALLOC_LARGE_REUSED, malloc_lage_reused);

            
                  X1(ANALYSIS_TOOL, analysis_tool);

            
                  X1(MALLOC_NANO, malloc_nano);

            
                  X1(MALLOC_MEDIUM, malloc_medium);

            
                  X1(MALLOC_PROB_GUARD, malloc_prob_guard);

            
                  X1(MACH_MSG, malloc_msg);

            
                  X1(IOKIT, IOKit);

            
                  X1(STACK, stack);

            
                  X1(GUARD, guard);

            
                  X1(SHARED_PMAP, shared_pmap);

            
                  X1(DYLIB, dylib);

            
                  X1(UNSHARED_PMAP, unshared_pmap);

            
                  X2(APPKIT, AppKit);

            
                  X2(FOUNDATION, Foundation);

            
                  X2(COREGRAPHICS, CoreGraphics);

            
                  X2(CORESERVICES, CoreServices); // is also VM_MEMORY_CARBON

            
                  X2(JAVA, Java);

            
                  X2(COREDATA, CoreData);

            
                  X1(COREDATA_OBJECTIDS, CodeData_objectids);

            
                  X1(ATS, ats);

            
                  X1(DYLD, dyld);

            
                  X1(DYLD_MALLOC, dyld_malloc);

            
                  X1(SQLITE, sqlite);

            
                  X1(JAVASCRIPT_CORE, javascript_core);

            
                  X1(JAVASCRIPT_JIT_EXECUTABLE_ALLOCATOR, javascript_jit_executable_allocator);

            
                  X1(JAVASCRIPT_JIT_REGISTER_FILE, javascript_jit_register_file);

            
                  X1(OPENCL, OpenCL);

            
                  X2(COREIMAGE, CoreImage);

            
                  X2(IMAGEIO, ImageIO);

            
                  X2(COREPROFILE, CoreProfile);

            
                  X1(APPLICATION_SPECIFIC_1, application_specific_1);

            
                  X1(APPLICATION_SPECIFIC_16, application_specific_16);

            
                  X1(OS_ALLOC_ONCE, os_alloc_once);

            
                  X1(GENEALOGY, genealogy);

            
                  default:

            
                    static char buffer[30];

            
                    snprintf(buffer, sizeof(buffer), "user_tag=0x%x(%d)", user_tag, user_tag);

            
                    return buffer;

            
                }

            
              }


              static void rwbits(int rw, char bits[4]) {

            
                bits[0] = rw & VM_PROT_READ ? 'r' : '-';

            
                bits[1] = rw & VM_PROT_WRITE ? 'w' : '-';

            
                bits[2] = rw & VM_PROT_EXECUTE ? 'x' : '-';

            
                bits[3] = 0;

            
              }

            
            };


            class ProcSmapsSummary {

            
              unsigned _num_mappings;

            
              size_t _private;

            
              size_t _committed;    // combined committed size

            
              size_t _reserved;     // reserved but not committed

            
              size_t _shared;       // combined shared size

            
              size_t _swapped_out;  // combined amount of swapped-out memory

            
            public:

            
              ProcSmapsSummary() : _num_mappings(0), _private(0),

            
                                   _committed(0), _shared(0), _swapped_out(0) {}


              void add_mapping(const proc_regioninfo& region_info) {

            
                _num_mappings++;


                bool is_private = region_info.pri_share_mode == SM_PRIVATE

            
                               || region_info.pri_share_mode == SM_PRIVATE_ALIASED;

            
                bool is_shared = region_info.pri_share_mode == SM_SHARED

            
                               || region_info.pri_share_mode == SM_SHARED_ALIASED

            
                               || region_info.pri_share_mode == SM_TRUESHARED

            
                               || region_info.pri_share_mode == SM_COW;

            
                bool is_committed = region_info.pri_share_mode == SM_EMPTY

            
                               && region_info.pri_max_protection == VM_PROT_ALL

            
                               && ((region_info.pri_protection & VM_PROT_DEFAULT) == VM_PROT_DEFAULT);

            
                bool is_reserved = region_info.pri_share_mode == SM_EMPTY

            
                               && region_info.pri_max_protection == VM_PROT_ALL

            
                               && region_info.pri_protection == VM_PROT_NONE;


                _private += is_private ? region_info.pri_size : 0;

            
                _shared += is_shared ? region_info.pri_size : 0;

            
                _swapped_out += region_info.pri_pages_swapped_out;

            
                _committed += is_committed ? region_info.pri_size : 0;

            
                _reserved += is_reserved ? region_info.pri_size : 0;

            
              }


              void print_on(const MappingPrintSession& session) const {

            
                outputStream* st = session.out();


                st->print_cr("Number of mappings: %u", _num_mappings);


                task_vm_info vm_info;

            
                mach_msg_type_number_t num_out = TASK_VM_INFO_COUNT;

            
                kern_return_t err = task_info(mach_task_self(), TASK_VM_INFO, (task_info_t)(&vm_info), &num_out);

            
                if (err == KERN_SUCCESS) {

            
                  st->print_cr("             vsize: %llu (%llu%s)", vm_info.virtual_size, PROPERFMTARGS(vm_info.virtual_size));

            
                  st->print_cr("               rss: %llu (%llu%s)", vm_info.resident_size, PROPERFMTARGS(vm_info.resident_size));

            
                  st->print_cr("          peak rss: %llu (%llu%s)", vm_info.resident_size_peak, PROPERFMTARGS(vm_info.resident_size_peak));

            
                  st->print_cr("         page size: %d (%ld%s)", vm_info.page_size, PROPERFMTARGS((size_t)vm_info.page_size));

            
                } else {

            
                  st->print_cr("error getting vm_info %d", err);

            
                }

            
                st->print_cr("          reserved: %zu (" PROPERFMT ")", _reserved, PROPERFMTARGS(_reserved));

            
                st->print_cr("         committed: %zu (" PROPERFMT ")", _committed, PROPERFMTARGS(_committed));

            
                st->print_cr("           private: %zu (" PROPERFMT ")", _private, PROPERFMTARGS(_private));

            
                st->print_cr("            shared: %zu (" PROPERFMT ")", _shared, PROPERFMTARGS(_shared));

            
                st->print_cr("       swapped out: %zu (" PROPERFMT ")", _swapped_out * vm_info.page_size, PROPERFMTARGS(_swapped_out * vm_info.page_size));

            
              }

            
            };


            class ProcSmapsPrinter {

            
              const MappingPrintSession& _session;

            
            public:

            
              ProcSmapsPrinter(const MappingPrintSession& session) :

            
                _session(session)

            
              {}


              void print_single_mapping(const proc_regioninfo& region_info, const MappingInfo& mapping_info) const {

            
                 outputStream* st = _session.out();

            
            #define INDENT_BY(n)          \

            
              if (st->fill_to(n) == 0) {  \

            
                st->print(" ");           \

            
              }

            
                st->print("%#014.12llx-%#014.12llx", (uint64_t)(mapping_info._address), (uint64_t)(mapping_info._address + mapping_info._size));

            
                INDENT_BY(38);

            
                st->print("%12ld", mapping_info._size);

            
                INDENT_BY(51);

            
                st->print("%s", mapping_info._protect_buffer.base());

            
                INDENT_BY(59);

            
                st->print("%s", mapping_info._share_buffer.base());

            
                st->print("%s", mapping_info._type_buffer.base());

            
                INDENT_BY(64);

            
                st->print("%#11llx", region_info.pri_offset);

            
                INDENT_BY(77);

            
                if (_session.print_nmt_info_for_region((const void*)mapping_info._address, (const void*)(mapping_info._address + mapping_info._size))) {

            
                  st->print(" ");

            
                } else {

            
                  const char* tag = mapping_info._tag_text;

            
                  if (tag != nullptr) {

            
                    st->print("[%s] ", tag);

            
                  }

            
                }


                st->print_raw(mapping_info._file_name.base());

            
                st->cr();


            #undef INDENT_BY

            
              }


              void print_legend() const {

            
                outputStream* st = _session.out();

            
                st->print_cr("from, to, vsize: address range and size");

            
                st->print_cr("prot:    protection:");

            
                st->print_cr("           rwx: read / write / execute");

            
                st->print_cr("share:   share mode:");

            
                st->print_cr("           cow: copy on write");

            
                st->print_cr("           pvt: private");

            
                st->print_cr("           shr: shared");

            
                st->print_cr("           tsh: true shared");

            
                st->print_cr("           p/a: private aliased");

            
                st->print_cr("           s/a: shared aliased");

            
                st->print_cr("           lpg: large page");

            
                st->print_cr("offset:  offset from start of allocation block");

            
                st->print_cr("vminfo:  VM information (requires NMT)");

            
                st->print_cr("file:    file mapped, if mapping is not anonymous");

            
                {

            
                  StreamIndentor si(st, 16);

            
                  _session.print_nmt_flag_legend();

            
                }

            
                st->print_cr("file:            file mapped, if mapping is not anonymous");

            
              }


              void print_header() const {

            
                outputStream* st = _session.out();

            
                //            0         1         2         3         4         5         6         7         8         9         0         1         2         3         4         5         6         7

            
                //            012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789

            
                //            0x000102890000-0x000102898000                32768 r--/r-- cow       0xc000 /Users/simont/dev/openjdk/jdk/build/macos-aarch64-fastdebug-shenandoah/images/jdk/bin/java

            
                st->print_cr("from               to                        vsize prot    share     offset  vminfo/file");

            
                st->print_cr("==================================================================================================");

            
              }

            
            };


            static bool is_interesting(const proc_regionwithpathinfo& info) {

            
               return info.prp_prinfo.pri_share_mode != SM_EMPTY

            
                      || info.prp_prinfo.pri_user_tag != 0

            
                      || info.prp_vip.vip_path[0] != '\0'

            
                      || info.prp_prinfo.pri_protection != 0

            
                      || info.prp_prinfo.pri_max_protection != 0;

            
            }


            void MemMapPrinter::pd_print_all_mappings(const MappingPrintSession& session) {


              ProcSmapsPrinter printer(session);

            
              ProcSmapsSummary summary;

            
              outputStream* const st = session.out();

            
              const pid_t pid = getpid();


              printer.print_legend();

            
              st->cr();

            
              printer.print_header();


              proc_regionwithpathinfo region_info_with_path;

            
              MappingInfo mapping_info;

            
              uint64_t address = 0;

            
              int region_count = 0;

            
              while (true) {

            
                if (++region_count > MAX_REGIONS_RETURNED) {

            
                  st->print_cr("limit of %d regions reached (results inaccurate)", region_count);

            
                  break;

            
                }

            
                ::bzero(&region_info_with_path, sizeof(region_info_with_path));

            
                int retval = proc_pidinfo(pid, PROC_PIDREGIONPATHINFO, (uint64_t)address, &region_info_with_path, sizeof(region_info_with_path));

            
                if (retval <= 0) {

            
                  break;

            
                } else if (retval < (int)sizeof(region_info_with_path)) {

            
                  st->print_cr("proc_pidinfo() returned %d", retval);

            
                  assert(false, "proc_pidinfo() returned %d", retval);

            
                }

            
                proc_regioninfo& region_info = region_info_with_path.prp_prinfo;

            
                if (is_interesting(region_info_with_path)) {

            
                  if (mapping_info.canCombine(region_info_with_path)) {

            
                    mapping_info.combineWithFollowing(region_info_with_path);

            
                  } else {

            
                    // print previous mapping info

            
                    // avoid printing the empty info at the start

            
                    if (mapping_info._size != 0) {

            
                      printer.print_single_mapping(region_info, mapping_info);

            
                    }

            
                    summary.add_mapping(region_info);

            
                    mapping_info.process(region_info_with_path);

            
                  }

            
                }

            
                assert(region_info.pri_size > 0, "size of region is 0");

            
                address = region_info.pri_address + region_info.pri_size;

            
              }

            
              printer.print_single_mapping(region_info_with_path.prp_prinfo, mapping_info);

            
              summary.add_mapping(region_info_with_path.prp_prinfo);

            
              st->cr();

            
              summary.print_on(session);

            
              st->cr();

            
            }

            
            #endif // __APPLE__
	/*
	* Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2023, 2024, Red Hat, Inc. and/or its affiliates.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*
	*/

	#if defined(__APPLE__)

	#include "nmt/memMapPrinter.hpp"
	#include "runtime/os.hpp"
	#include "utilities/align.hpp"
	#include "utilities/globalDefinitions.hpp"
	#include "utilities/ostream.hpp"
	#include "utilities/powerOfTwo.hpp"

	#include <limits.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <libproc.h>
	#include <unistd.h>

	#include <mach/vm_inherit.h>
	#include <mach/vm_prot.h>
	#include <mach/mach_vm.h>

	// maximum number of mapping records returned
	static const int MAX_REGIONS_RETURNED = 1000000;

	// ::mmap() on MacOS is a layer on top of Mach system calls, and will allocate in 128MB chunks.
	// This code will coalesce a series of identical 128GB chunks (maybe followed by one smaller chunk
	// with identical flags) into one.
	// Unfortunately, two or more identically allocated contiguous sections will appear as one, if the
	// first section is size 128MB. vmmap(1) has the same issue.
	static const int MACOS_PARTIAL_ALLOCATION_SIZE = 128 * M;

	class MappingInfo {
	proc_regioninfo _rinfo;
	public:
	const char* _address;
	size_t _size;
	stringStream _share_buffer;
	stringStream _type_buffer;
	stringStream _protect_buffer;
	stringStream _file_name;
	const char* _tag_text;

	MappingInfo() : _address(nullptr), _size(0), _tag_text(nullptr) {}

	void reset() {
	_share_buffer.reset();
	_protect_buffer.reset();
	_type_buffer.reset();
	_file_name.reset();
	_tag_text = nullptr;
	}

	bool canCombine(const proc_regionwithpathinfo& mem_info) {
	const proc_regioninfo& n = mem_info.prp_prinfo;
	bool cc = _rinfo.pri_size == MACOS_PARTIAL_ALLOCATION_SIZE
	&& n.pri_address == (_rinfo.pri_address + _size)
	&& n.pri_protection == _rinfo.pri_protection
	&& n.pri_max_protection == _rinfo.pri_max_protection
	&& n.pri_user_tag == _rinfo.pri_user_tag
	&& n.pri_share_mode == _rinfo.pri_share_mode
	&& n.pri_offset == 0;
	return cc;
	}

	void combineWithFollowing(const proc_regionwithpathinfo& mem_info) {
	_size += mem_info.prp_prinfo.pri_size;
	}

	void process(const proc_regionwithpathinfo& mem_info) {
	reset();

	_rinfo = mem_info.prp_prinfo;

	_address = (const char*) _rinfo.pri_address;
	_size = _rinfo.pri_size;

	if (mem_info.prp_vip.vip_path[0] != '\0') {
	_file_name.print_raw(mem_info.prp_vip.vip_path);
	}
	// proc_regionfilename() seems to give bad results, so we don't try to use it here.

	char prot[4];
	char maxprot[4];
	rwbits(_rinfo.pri_protection, prot);
	rwbits(_rinfo.pri_max_protection, maxprot);
	_protect_buffer.print("%s/%s", prot, maxprot);

	get_share_mode(_share_buffer, _rinfo);
	_tag_text = tagToStr(_rinfo.pri_user_tag);
	}

	static void get_share_mode(outputStream& out, const proc_regioninfo& rinfo) {
	static const char* share_strings[] = {
	"cow", "pvt", "---", "shr", "tsh", "p/a", "s/a", "lpg"
	};
	assert(SM_COW == 1 && SM_LARGE_PAGE == (sizeof(share_strings)/sizeof(share_strings[0])), "share_mode contants are out of range"); // the +1 offset is intentional; see below
	const bool valid_share_mode = rinfo.pri_share_mode >= SM_COW && rinfo.pri_share_mode <= SM_LARGE_PAGE;
	if (valid_share_mode) {
	int share_mode = rinfo.pri_share_mode;
	out.print_raw(share_strings[share_mode - 1]);
	} else {
	out.print_cr("invalid pri_share_mode (%d)", rinfo.pri_share_mode);
	assert(valid_share_mode, "invalid pri_share_mode (%d)", rinfo.pri_share_mode);
	}
	}

	#define X1(TAG, DESCR) X2(TAG, DESCR)
	#define X2(TAG, DESCRIPTION) case VM_MEMORY_ ## TAG: return # DESCRIPTION;
	static const char* tagToStr(uint32_t user_tag) {
	switch (user_tag) {
	case 0:
	return 0;
	X1(MALLOC, malloc);
	X1(MALLOC_SMALL, malloc_small);
	X1(MALLOC_LARGE, malloc_large);
	X1(MALLOC_HUGE, malloc_huge);
	X1(SBRK, sbrk);
	X1(REALLOC, realloc);
	X1(MALLOC_TINY, malloc_tiny);
	X1(MALLOC_LARGE_REUSABLE, malloc_large_reusable);
	X1(MALLOC_LARGE_REUSED, malloc_lage_reused);
	X1(ANALYSIS_TOOL, analysis_tool);
	X1(MALLOC_NANO, malloc_nano);
	X1(MALLOC_MEDIUM, malloc_medium);
	X1(MALLOC_PROB_GUARD, malloc_prob_guard);
	X1(MACH_MSG, malloc_msg);
	X1(IOKIT, IOKit);
	X1(STACK, stack);
	X1(GUARD, guard);
	X1(SHARED_PMAP, shared_pmap);
	X1(DYLIB, dylib);
	X1(UNSHARED_PMAP, unshared_pmap);
	X2(APPKIT, AppKit);
	X2(FOUNDATION, Foundation);
	X2(COREGRAPHICS, CoreGraphics);
	X2(CORESERVICES, CoreServices); // is also VM_MEMORY_CARBON
	X2(JAVA, Java);
	X2(COREDATA, CoreData);
	X1(COREDATA_OBJECTIDS, CodeData_objectids);
	X1(ATS, ats);
	X1(DYLD, dyld);
	X1(DYLD_MALLOC, dyld_malloc);
	X1(SQLITE, sqlite);
	X1(JAVASCRIPT_CORE, javascript_core);
	X1(JAVASCRIPT_JIT_EXECUTABLE_ALLOCATOR, javascript_jit_executable_allocator);
	X1(JAVASCRIPT_JIT_REGISTER_FILE, javascript_jit_register_file);
	X1(OPENCL, OpenCL);
	X2(COREIMAGE, CoreImage);
	X2(IMAGEIO, ImageIO);
	X2(COREPROFILE, CoreProfile);
	X1(APPLICATION_SPECIFIC_1, application_specific_1);
	X1(APPLICATION_SPECIFIC_16, application_specific_16);
	X1(OS_ALLOC_ONCE, os_alloc_once);
	X1(GENEALOGY, genealogy);
	default:
	static char buffer[30];
	snprintf(buffer, sizeof(buffer), "user_tag=0x%x(%d)", user_tag, user_tag);
	return buffer;
	}
	}

	static void rwbits(int rw, char bits[4]) {
	bits[0] = rw & VM_PROT_READ ? 'r' : '-';
	bits[1] = rw & VM_PROT_WRITE ? 'w' : '-';
	bits[2] = rw & VM_PROT_EXECUTE ? 'x' : '-';
	bits[3] = 0;
	}
	};

	class ProcSmapsSummary {
	unsigned _num_mappings;
	size_t _private;
	size_t _committed; // combined committed size
	size_t _reserved; // reserved but not committed
	size_t _shared; // combined shared size
	size_t _swapped_out; // combined amount of swapped-out memory
	public:
	ProcSmapsSummary() : _num_mappings(0), _private(0),
	_committed(0), _shared(0), _swapped_out(0) {}

	void add_mapping(const proc_regioninfo& region_info) {
	_num_mappings++;

	bool is_private = region_info.pri_share_mode == SM_PRIVATE
	\|\| region_info.pri_share_mode == SM_PRIVATE_ALIASED;
	bool is_shared = region_info.pri_share_mode == SM_SHARED
	\|\| region_info.pri_share_mode == SM_SHARED_ALIASED
	\|\| region_info.pri_share_mode == SM_TRUESHARED
	\|\| region_info.pri_share_mode == SM_COW;
	bool is_committed = region_info.pri_share_mode == SM_EMPTY
	&& region_info.pri_max_protection == VM_PROT_ALL
	&& ((region_info.pri_protection & VM_PROT_DEFAULT) == VM_PROT_DEFAULT);
	bool is_reserved = region_info.pri_share_mode == SM_EMPTY
	&& region_info.pri_max_protection == VM_PROT_ALL
	&& region_info.pri_protection == VM_PROT_NONE;

	_private += is_private ? region_info.pri_size : 0;
	_shared += is_shared ? region_info.pri_size : 0;
	_swapped_out += region_info.pri_pages_swapped_out;
	_committed += is_committed ? region_info.pri_size : 0;
	_reserved += is_reserved ? region_info.pri_size : 0;
	}

	void print_on(const MappingPrintSession& session) const {
	outputStream* st = session.out();

	st->print_cr("Number of mappings: %u", _num_mappings);

	task_vm_info vm_info;
	mach_msg_type_number_t num_out = TASK_VM_INFO_COUNT;
	kern_return_t err = task_info(mach_task_self(), TASK_VM_INFO, (task_info_t)(&vm_info), &num_out);
	if (err == KERN_SUCCESS) {
	st->print_cr(" vsize: %llu (%llu%s)", vm_info.virtual_size, PROPERFMTARGS(vm_info.virtual_size));
	st->print_cr(" rss: %llu (%llu%s)", vm_info.resident_size, PROPERFMTARGS(vm_info.resident_size));
	st->print_cr(" peak rss: %llu (%llu%s)", vm_info.resident_size_peak, PROPERFMTARGS(vm_info.resident_size_peak));
	st->print_cr(" page size: %d (%ld%s)", vm_info.page_size, PROPERFMTARGS((size_t)vm_info.page_size));
	} else {
	st->print_cr("error getting vm_info %d", err);
	}
	st->print_cr(" reserved: %zu (" PROPERFMT ")", _reserved, PROPERFMTARGS(_reserved));
	st->print_cr(" committed: %zu (" PROPERFMT ")", _committed, PROPERFMTARGS(_committed));
	st->print_cr(" private: %zu (" PROPERFMT ")", _private, PROPERFMTARGS(_private));
	st->print_cr(" shared: %zu (" PROPERFMT ")", _shared, PROPERFMTARGS(_shared));
	st->print_cr(" swapped out: %zu (" PROPERFMT ")", _swapped_out * vm_info.page_size, PROPERFMTARGS(_swapped_out * vm_info.page_size));
	}
	};

	class ProcSmapsPrinter {
	const MappingPrintSession& _session;
	public:
	ProcSmapsPrinter(const MappingPrintSession& session) :
	_session(session)
	{}

	void print_single_mapping(const proc_regioninfo& region_info, const MappingInfo& mapping_info) const {
	outputStream* st = _session.out();
	#define INDENT_BY(n) \
	if (st->fill_to(n) == 0) { \
	st->print(" "); \
	}
	st->print("%#014.12llx-%#014.12llx", (uint64_t)(mapping_info._address), (uint64_t)(mapping_info._address + mapping_info._size));
	INDENT_BY(38);
	st->print("%12ld", mapping_info._size);
	INDENT_BY(51);
	st->print("%s", mapping_info._protect_buffer.base());
	INDENT_BY(59);
	st->print("%s", mapping_info._share_buffer.base());
	st->print("%s", mapping_info._type_buffer.base());
	INDENT_BY(64);
	st->print("%#11llx", region_info.pri_offset);
	INDENT_BY(77);
	if (_session.print_nmt_info_for_region((const void)mapping_info._address, (const void)(mapping_info._address + mapping_info._size))) {
	st->print(" ");
	} else {
	const char* tag = mapping_info._tag_text;
	if (tag != nullptr) {
	st->print("[%s] ", tag);
	}
	}

	st->print_raw(mapping_info._file_name.base());
	st->cr();

	#undef INDENT_BY
	}

	void print_legend() const {
	outputStream* st = _session.out();
	st->print_cr("from, to, vsize: address range and size");
	st->print_cr("prot: protection:");
	st->print_cr(" rwx: read / write / execute");
	st->print_cr("share: share mode:");
	st->print_cr(" cow: copy on write");
	st->print_cr(" pvt: private");
	st->print_cr(" shr: shared");
	st->print_cr(" tsh: true shared");
	st->print_cr(" p/a: private aliased");
	st->print_cr(" s/a: shared aliased");
	st->print_cr(" lpg: large page");
	st->print_cr("offset: offset from start of allocation block");
	st->print_cr("vminfo: VM information (requires NMT)");
	st->print_cr("file: file mapped, if mapping is not anonymous");
	{
	StreamIndentor si(st, 16);
	_session.print_nmt_flag_legend();
	}
	st->print_cr("file: file mapped, if mapping is not anonymous");
	}

	void print_header() const {
	outputStream* st = _session.out();
	// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7
	// 012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
	// 0x000102890000-0x000102898000 32768 r--/r-- cow 0xc000 /Users/simont/dev/openjdk/jdk/build/macos-aarch64-fastdebug-shenandoah/images/jdk/bin/java
	st->print_cr("from to vsize prot share offset vminfo/file");
	st->print_cr("==================================================================================================");
	}
	};

	static bool is_interesting(const proc_regionwithpathinfo& info) {
	return info.prp_prinfo.pri_share_mode != SM_EMPTY
	\|\| info.prp_prinfo.pri_user_tag != 0
	\|\| info.prp_vip.vip_path[0] != '\0'
	\|\| info.prp_prinfo.pri_protection != 0
	\|\| info.prp_prinfo.pri_max_protection != 0;
	}

	void MemMapPrinter::pd_print_all_mappings(const MappingPrintSession& session) {

	ProcSmapsPrinter printer(session);
	ProcSmapsSummary summary;
	outputStream* const st = session.out();
	const pid_t pid = getpid();

	printer.print_legend();
	st->cr();
	printer.print_header();

	proc_regionwithpathinfo region_info_with_path;
	MappingInfo mapping_info;
	uint64_t address = 0;
	int region_count = 0;
	while (true) {
	if (++region_count > MAX_REGIONS_RETURNED) {
	st->print_cr("limit of %d regions reached (results inaccurate)", region_count);
	break;
	}
	::bzero(&region_info_with_path, sizeof(region_info_with_path));
	int retval = proc_pidinfo(pid, PROC_PIDREGIONPATHINFO, (uint64_t)address, &region_info_with_path, sizeof(region_info_with_path));
	if (retval <= 0) {
	break;
	} else if (retval < (int)sizeof(region_info_with_path)) {
	st->print_cr("proc_pidinfo() returned %d", retval);
	assert(false, "proc_pidinfo() returned %d", retval);
	}
	proc_regioninfo& region_info = region_info_with_path.prp_prinfo;
	if (is_interesting(region_info_with_path)) {
	if (mapping_info.canCombine(region_info_with_path)) {
	mapping_info.combineWithFollowing(region_info_with_path);
	} else {
	// print previous mapping info
	// avoid printing the empty info at the start
	if (mapping_info._size != 0) {
	printer.print_single_mapping(region_info, mapping_info);
	}
	summary.add_mapping(region_info);
	mapping_info.process(region_info_with_path);
	}
	}
	assert(region_info.pri_size > 0, "size of region is 0");
	address = region_info.pri_address + region_info.pri_size;
	}
	printer.print_single_mapping(region_info_with_path.prp_prinfo, mapping_info);
	summary.add_mapping(region_info_with_path.prp_prinfo);
	st->cr();
	summary.print_on(session);
	st->cr();
	}
	#endif // __APPLE__