// when emitting locations.
func (b *profileBuilder) readMapping() {
	data, _ := os.ReadFile("/proc/self/maps")
	parseProcSelfMaps(data, b.addMapping)
	if len(b.mem) == 0 { // pprof expects a map entry, so fake one.
		b.addMappingEntry(0, 0, 0, "", "", true)
		// TODO(hyangah): make addMapping return *memMap or
		// take a memMap struct, and get rid of addMappingEntry
		// that takes a bunch of positional arguments.
	}
}

	return (protection&_VM_PROT_EXECUTE) != 0 && (protection&_VM_PROT_READ) != 0
}

// machVMInfo uses the mach_vm_region region system call to add mapping entries
// for the text region of the running process.
func machVMInfo(addMapping func(lo, hi, offset uint64, file, buildID string)) bool {
	added := false
	var addr uint64 = 0x1
	for {
		var memRegionSize uint64
		var info machVMRegionBasicInfoData
		// Get the first address and page size.

// text region of the running process. Note that currently no attempt is
// made to obtain the buildID information.
func (b *profileBuilder) readMapping() {
	if !machVMInfo(b.addMapping) {
		b.addMappingEntry(0, 0, 0, "", "", true)
	}
}

func readMainModuleMapping() (start, end uint64, exe, buildID string, err error) {
	first := true
	ok := machVMInfo(func(lo, hi, off uint64, file, build string) {

		return fmt.Errorf("parse certificate from rootPEM got error: %v", err)
	}

	v.AddMapping(trustDomain, rootCAs)
	return nil
}

// AddMappings merges a trust domain to certs map to the certPools map.
func (v *PeerCertVerifier) AddMappings(certMap map[string][]*x509.Certificate) {
	for trustDomain, certs := range certMap {
		v.AddMapping(trustDomain, certs)
	}
}

            // ignore
        } catch (final Exception e) {
            logger.warn("{} is not found.", aliasConfigPath, e);
        }
        return false;
    }

    public static boolean addMapping(final IndicesAdminClient indicesClient, final String index, final String docType,
            final String indexResourcePath) {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();

		return 0, 0, false, fmt.Errorf("failed to parse vmmap output, vmmap did not report an error: %v", err)
	}
	return hi, lo, false, nil
}

// parseVmmap parses the output of vmmap and calls addMapping for the first r-x TEXT segment in the output.
func parseVmmap(data []byte) (hi, lo uint64, err error) {
	// vmmap 53799
	// Process:         gopls [53799]
	// Path:            /Users/USER/*/gopls

		// If we do need it, it would go here, before we
		// enter the mappings into b.mem in the first place.

		buildID, _ := elfBuildID(file)
		addMapping(lo, hi, offset, file, buildID)
	}
}

func (b *profileBuilder) addMapping(lo, hi, offset uint64, file, buildID string) {
	b.addMappingEntry(lo, hi, offset, file, buildID, false)
}

            searchEngineClient.admin().cluster().prepareHealth(toIndex).setWaitForYellowStatus().execute(ActionListener.wrap(response -> {
                searchEngineClient.addMapping(docIndex, "doc", toIndex);
                if (searchEngineClient.copyDocIndex(fromIndex, toIndex, replaceAliases)
                        && (replaceAliases && !searchEngineClient.updateAlias(toIndex))) {

                    if (!exists) {
                        createIndex(configIndex, indexName);
                        createAlias(configIndex, indexName);
                    }
                }

                addMapping(configIndex, configType, indexName);
            } else {
                logger.warn("Invalid index config name: {}", configName);
            }
        });
    }

						t.Fatalf("Failed to parse certificate: " + err.Error())
					}
					certMap[trustDomain] = append(certMap[trustDomain], rootCert)
				}
			}

			verifier := NewPeerCertVerifier()
			verifier.AddMappings(certMap)
			if verifier == nil {
				t.Fatalf("Failed to create peer cert verifier.")
			}
			client := &http.Client{
				Timeout: time.Second,
				Transport: &http.Transport{