By John GruberApple TV, now with more Tailscale. Try Tailscale for Apple TV now.Blah blah blah, something something something about how most people don’t

The iPhones 15 Pro (and iPhones 15) – Daring Fireball

Microsoft has published a detailed profile of a native English-speaking threat actor with advanced social engineering capabilities it tracks as Octo Tempest, that targets companies in data extortion and ransomware attacks.

Microsoft: Octo Tempest is one of the most dangerous financial hacking groups

Lumeo, a designer of computer vision solutions, has announced the launch of “Lumeo-Ready” Gateways, in partnership with AIMobile, Seeed Studio, and Velasea.

Lumeo announces “Lumeo-Ready” Gateways to accelerate field deployments

Tailscale is also now available on Apple TV. Tailscale lets you create your own secure peer-to-peer network without relying on an intermediate company server network. You can choose an exit node ...

Best VPN apps for Apple TV

The only other option that comes to mind is to use services like Tailscale / Zerotier to create a virtual network. Yes, unfortunately this £3 change has placed you on CGNAT and caused the issues you’ve described including the increased outages.

WAN IP Address Issue

Mullvad’s privacy VPN capabilities coupled with Tailscale peer-to-peer mesh connections can provide secure internet browsing from any location while preserving user anonymity.

Tailscale, Mullvad partner to deliver secure, private web browsing

The newly emerged ransomware actively targets both Windows and Linux systems with a double-extortion approach.

Akira Ransomware Mutates to Target Linux Systems

Alternatively, you may want to explore other solutions that are more suited for OT (Operational Technology) environments, such as Tailscale. Tailscale is a zero trust network that uses WireGuard ...

VPN vs Jump Host (Box)

Setting up a VPN on your Apple TV 4K allows you to avoid geographic region restrictions and access services not normally available to you. With tvOS 17, VPN apps can now be installed on the Apple TV directly. FlowVPN is the first VPN app available to ...

FlowVPN is the first VPN app available to download for the Apple TV set-top box, with more VPN providers jumping onboard now that tvOS 17 is live. Here’s all the best VPN apps for Apple TV available now …

Tailscale

tailscale

We are back with another Company of the Week feature! Every week, we share an awesome tech brand from our tech company database, making their evergreen mark on the internet. This unique HackerNoon database ranks S&P 500 companies and top startups of the year alike. This week, we proudly present Tailscale, a secure, private, identity-based, infrastructure-agnostic network with a flexible topology, resilient networking, and streamlined setup. It allows devices to connect securely over the internet as if they were on the same local network, without needing complicated setup. Built on the WireGuard protocol, Tailscale is ideal for teams who need secure access to resources and networks from anywhere. Want to be featured on HackerNoon’s Company of the Week? Request Your Tech Company Page on HackerNoon! Meet Tailscale: #FunFact Tailscale's mission is to help people create secure networks centered around their personal connections. According to Tailscale, their service is designed to make networking both safe and simple, whether you're connecting with co-workers to share prototypes, accessing a company database securely, or sharing files and photos with family members. They focus on eliminating the overhead and complexity often associated with software and operational challenges. By simplifying and securing connectivity, Tailscale aims to enable teams to build scalable systems without adding unnecessary complexity. We are committed to always safeguarding your data. Every connection is encrypted end-to-end using WireGuard®, a modern VPN protocol designed for usability, performance, and security. Stay up-to-date on updates via our security bulletin below. Tailscale's three main guiding principles are: Real people solving concrete problems: Decentralization, encryption, and scalability are means to an end, not the ends in themselves.  Their mission is to solve tech problems for diverse teams across various industries, with a team that mirrors this diversity and brings empathy to their work.
Small is beautiful: Tailscale values the effectiveness of small, skilled teams over large groups. They believe that smaller teams are capable of producing more excellent, coherent, and beautiful outcomes, which larger teams or networks often struggle to replicate.
It has to “just work”: Tailscale emphasizes the importance of reliability and simplicity. Their goal is to ensure their systems function seamlessly, allowing users to focus on their core work without being bogged down by technical issues. Share Your Company's Story via HackerNoon Tailscale <> HackerNoon Targeted Ads Tailscale joined hundreds of brands that partnered with HackerNoon for targeted ads! Here is how our ads work: Let’s say that you want to advertise your AI-based product. Naturally, you’d want to display your AD to those reading AI stories. But you’d also want to display your AD to not just those reading Artificial Intelligence stories, but also to those reading Machine Learning stories, TensorFlow stories, Deep Learning stories, Computer Vision stories, and so on. HackerNoon goes a step further and creates categories customized to your audience based on a cluster of tags that usually go together. Our offer? 0.2% CTR & $5 CPC Ads with 7 ICPs to choose from 😉 Learn more about HackerNoon Targeted Ads here.
Learn How You Can Book a Spot on HackerNoon’s Billboard That's all this week, folks! Stay Creative, Stay Iconic. The HackerNoon Team We are back with another Company of the Week feature! Every week, we share an awesome tech brand from our tech company database , making their evergreen mark on the internet. This unique HackerNoon database ranks S&P 500 companies and top startups of the year alike. Company of the Week tech company database This week, we proudly present Tailscale , a secure, private, identity-based, infrastructure-agnostic network with a flexible topology, resilient networking, and streamlined setup. It allows devices to connect securely over the internet as if they were on the same local network, without needing complicated setup. Built on the WireGuard protocol, Tailscale is ideal for teams who need secure access to resources and networks from anywhere. Tailscale Want to be featured on HackerNoon’s Company of the Week? Request Your Tech Company Page on HackerNoon! Want to be featured on HackerNoon’s Company of the Week? Request Your Tech Company Page on HackerNoon ! Want to be featured on HackerNoon’s Company of the Week? Request Your Tech Company Page on HackerNoon Want to be featured on HackerNoon’s Company of the Week? Request Your Tech Company Page on HackerNoon Meet Tailscale: #FunFact Tailscale 's mission is to help people create secure networks centered around their personal connections. According to Tailscale, their service is designed to make networking both safe and simple, whether you're connecting with co-workers to share prototypes, accessing a company database securely, or sharing files and photos with family members. They focus on eliminating the overhead and complexity often associated with software and operational challenges. By simplifying and securing connectivity, Tailscale aims to enable teams to build scalable systems without adding unnecessary complexity. Tailscale We are committed to always safeguarding your data. Every connection is encrypted end-to-end using WireGuard®, a modern VPN protocol designed for usability, performance, and security. Stay up-to-date on updates via our security bulletin below. We are committed to always safeguarding your data. Every connection is encrypted end-to-end using WireGuard®, a modern VPN protocol designed for usability, performance, and security. Stay up-to-date on updates via our security bulletin below. Tailscale's three main guiding principles are: Tailscale's three main guiding principles are: Real people solving concrete problems: Decentralization, encryption, and scalability are means to an end, not the ends in themselves.  Their mission is to solve tech problems for diverse teams across various industries, with a team that mirrors this diversity and brings empathy to their work. Small is beautiful: Tailscale values the effectiveness of small, skilled teams over large groups. They believe that smaller teams are capable of producing more excellent, coherent, and beautiful outcomes, which larger teams or networks often struggle to replicate. It has to “just work”: Tailscale emphasizes the importance of reliability and simplicity. Their goal is to ensure their systems function seamlessly, allowing users to focus on their core work without being bogged down by technical issues. Real people solving concrete problems: Decentralization, encryption, and scalability are means to an end, not the ends in themselves.  Their mission is to solve tech problems for diverse teams across various industries, with a team that mirrors this diversity and brings empathy to their work. Real people solving concrete problems: Small is beautiful: Tailscale values the effectiveness of small, skilled teams over large groups. They believe that smaller teams are capable of producing more excellent, coherent, and beautiful outcomes, which larger teams or networks often struggle to replicate. Small is beautiful: It has to “just work”: Tailscale emphasizes the importance of reliability and simplicity. Their goal is to ensure their systems function seamlessly, allowing users to focus on their core work without being bogged down by technical issues. It has to “just work”: Share Your Company's Story via HackerNoon Share Your Company's Story via HackerNoon Share Your Company's Story via HackerNoon Tailscale <> HackerNoon Targeted Ads <> Tailscale joined hundreds of brands that partnered with HackerNoon for targeted ads ! targeted ads Here is how our ads work: Here is how our ads work: Let’s say that you want to advertise your AI-based product. Naturally, you’d want to display your AD to those reading AI stories. But you’d also want to display your AD to not just those reading Artificial Intelligence stories, but also to those reading Machine Learning stories, TensorFlow stories, Deep Learning stories, Computer Vision stories, and so on . HackerNoon goes a step further and creates categories customized to your audience based on a cluster of tags that usually go together. AI AI Artificial Intelligence Artificial Intelligence Machine Learning TensorFlow TensorFlow Deep Learning Deep Learning Computer Vision Computer Vision so on so on Our offer? 0.2% CTR & $5 CPC Ads with 7 ICPs to choose from 😉 Our offer? 0.2% CTR & $5 CPC Ads with 7 ICPs to choose from Learn more about HackerNoon Targeted Ads here. Learn How You Can Book a Spot on HackerNoon’s Billboard Learn more about HackerNoon Targeted Ads here . here here Learn How You Can Book a Spot on HackerNoon’s Billboard Learn How You Can Book a Spot on HackerNoon’s Billboard That's all this week, folks! Stay Creative, Stay Iconic. The HackerNoon Team

Meet Tailscale: HackerNoon Company of the Week

ይተዋወቁ Tailsscale: HackerNoon የሳምንቱ ኩባንያ

تعرف على Tailscale: شركة HackerNoon لهذا الأسبوع

মেট টেলস্কেল: হ্যাকারনুন কোম্পানি অফ দ্য উইক

Conozca Tailscale: la empresa de la semana de HackerNoon

Découvrez Tailscale : l'entreprise de la semaine selon HackerNoon

הכירו את Tailscale: חברת השבוע של HackerNoon

Rankontre Tailscale: HackerNoon Konpayi semèn nan

Tailscale のご紹介: HackerNoon の今週の企業

Conheça a Tailscale: Empresa da Semana da HackerNoon

พบกับ Tailscale: บริษัท HackerNoon แห่งสัปดาห์นี้

Meet Tailscale: ናይዚ ሰሙን ትካል ሃከርኑን።

Private Networks: How Tailscale Works

Here's Why Scale Is Vital for Search Engines

93 Stories To Learn About Networking

167 Stories To Learn About Vpn

Problem Residential proxies have a lot of useful applications, such as web scraping, online research, bypassing geo-restrictions and anonymous browsing. But, they can be expensive, with some charging more than $100 a month for access to over 10 GB of data. Last year, when I was travelling to India and other parts of Southeast Asia, I wanted a reliable way which would let me access content on various subscription services like Netflix and Amazon Prime without geo-restrictions. I wanted to do this while Not having to pay more than $100 per month for VPN/residential proxy service. Also, Netflix would occasionally block me when using VPN. Not paying an additional amount for a static IP for my home internet connection back in the US. Solution I discovered a solution by creating my own residential proxy on my home desktop in the US. By setting up a peer-to-peer(P2P) VPN and connecting my laptop and desktop to it, I was able to route the traffic of my laptop in India to my desktop in the US, which then forwarded these requests to www/public internet before returning the response from my home network. All this without having to go through the hassle of setting up connection forwarding configuration in my home router. What is a P2P VPN Peer-to-peer(P2P) is an architecture model for VPNs used to create a secure shared environment for users. A P2P based VPN differs from the standard hub-and-spoke model by not routing all traffic through a central server, avoiding congestion. This improves security and allows for more efficient scaling by adding nodes without overburdening the network. Additionally, connections in a P2P VPN utilize the quickest path, reducing delays. There a multiple open-source, freemium and paid P2P VPN solutions available. Tinc is one of popular open-source VPN. How does the network setup look? The network stack consists of the following components: Desktop at home (US) My laptop (Outside US) P2P vpn daemon running on both machine via same account Http proxy server running on the desktop The diagram below depicts the flow of information to retrieve a public webpage from my laptop outside of the US. I wanted a P2P VPN which is easy to setup and requires near-zero config. I ended up using tailscale. The steps below are mostly generic for any VPN but you may find this most suitable if using tailscale. Steps taken to setup this network : Setting up the vpn client on desktop and laptop Download and install VPN client on desktop and laptop. If using a zero-config VPN, register your account with vpn and sign-in on both the machines with the same account : Setting up a forward http proxy server on desktop You can use any open source proxy server. I used https://github.com/abhinavsingh/proxy.py as it was easy to set up. I ran it within a docker container. The docker image for this proxy is available on docker hub.  To run it within a docker container you can execute this command docker run -it -p 8899:8899 --rm abhinavsingh/proxy.py:latest In the command above, the proxy server is listening on port 8899. This will be useful when we specify the url of proxy server in the applications within the laptop : After installing and signing into your VPN account, lets figure out the ip address of the desktop which will be used by the laptop to forward its http requests . Identify the ip address of desktop in the VPN network For this, you can list the ip addresses for all the network interfaces on the desktop. Then identify the ip address for an interface whose name starts with the name of your VPN client, for my case, it starts with “tailscale”. I used the command on my linux machine’s terminal to identify the ip address ip $ ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
….
4: tailscale0: <POINTOPOINT,MULTICAST,NOARP,UP,LOWER_UP> mtu 1280 qdisc fq_codel state UNKNOWN group default qlen 500
    link/none 
    inet 100.113.xxx.xx/32 scope global tailscale0
       valid_lft forever preferred_lft forever
 … Here I was able to find the ip address of desktop within my local tailscale network in the network interface : tailscale0 100.113.xxx.xx Using the address of proxy server on laptop to access public web: Now that we know the ip address of desktop (let's call it ) and the port number for the http proxy server on desktop (let’s call it ), we can forward all the network traffic from laptop via proxy address . $ip_desktop $proxy_port http://$ip_desktop:$proxy_port For example you can send a curl request to example.com from laptop via desktop like curl --proxy "http://$ip_desktop:$proxy_port" "https://example.com" Using the proxy server The above instructions demonstrate how to create a free residential proxy server while travelling using a spare computer at home. Now you can use this proxy address on your personal laptop in any of the following ways: Within your application code inside the http client libraries of your web framework/language (requests in python, fetch in javascript etc) For all the web requests from your laptop. This way you can forward any kind http request via desktop’s proxy server. In ubuntu you can do this by following these steps https://help.ubuntu.com/stable/ubuntu-help/net-proxy.html.en Just in your browser. Although Chrome and Firefox don’t provide a native way to setup exclusive http proxy settings for them, you can do this via extensions like https://github.com/foxyproxy/firefox-extension I chose 2. and forwarded all the http requests from my laptop to desktop. I used this setup for more than two months without any noticeable downtime. Conclusion In this article we went over how to setup a personal residential proxy using P2P VPN Two or more personal computers Depending on the choice of the VPN, the whole setup can be done without any additional cost, assuming you already own multiple computers. Using this residential proxy you can then access the internet anonymously without any geo-restrictions due to your current physical location.

How to Create a Personal Residential Proxy to Bypass Geo Restrictions

জিও সীমাবদ্ধতা বাইপাস করার জন্য কীভাবে একটি ব্যক্তিগত আবাসিক প্রক্সি তৈরি করবেন

So erstellen Sie einen persönlichen Wohn-Proxy, um geografische Beschränkungen zu umgehen

Cómo crear un proxy residencial personal para eludir las restricciones geográficas

Comment créer un proxy résidentiel personnel pour contourner les restrictions géographiques

भू-प्रतिबंधों को बायपास करने के लिए व्यक्तिगत आवासीय प्रॉक्सी कैसे बनाएं

地理的制限を回避するための個人用の住宅用プロキシを作成する方法

지리적 제한을 우회하기 위해 개인 주거용 프록시를 만드는 방법

Como criar um proxy residencial pessoal para contornar as restrições geográficas

Coğrafi Kısıtlamaları Aşmak için Kişisel Konut Proxy'si Nasıl Oluşturulur

Cách tạo Proxy dân cư cá nhân để vượt qua các hạn chế về địa lý

如何创建个人住宅代理来绕过地理限制

Over time most Linux aficionados accrue a sparkling war chest full of hard-won tricks that can come in tremendously handy when a situation demands quick thinking at your terminal. I stashed away many of these bits of knowledge over the years and whenever I had the opportunity to watch over the shoulder of somebody exceptionally well-versed with Linux. Today, you're pairing with me at the terminal. We're exploring the depths of Linux filesystem and shell tools and tricks. Take a with me /proc One of the most useful directories in a Linux system is . From the page for : /proc man proc The proc filesystem is a pseudo-filesystem which provides an interface to kernel data structures. When the page says "pseudo-filesystem", it means that if you were to peek underneath your disk where you might expect to find bits representing a file like you would for a text file at , there's nothing at . It's present and alive on a running Linux system, but entirely absent if you were to pull the disk out and inspect it. a control panel for your running kernel! man /tmp/launch-codes.txt /proc /proc If you were to take a look in your own right now, you might find a lot of directories like the following: /proc ls /proc 1
10
10021
10059
10144
...hundreds more files... Each of those numbers represents a process ID, or – yes, the same that identifies the process for your browser or terminal program. In fact, you can interrogate lots of information about the process itself. For example, you might recall that process on a Linux system is traditionally the top-level process, which in most modern systems is systemd-based. Let's see the command that kicked off on my system: PID PID 1 init PID 1 cat /proc/1/cmdline /run/current-system/systemd/lib/systemd/systemd is a file that tells us the command that kicked off process - in this case, itself. cmdline 1 systemd There's a file in that is particularly useful - , which actually shows you the arguments passed to your kernel itself at boot time. Mine is very wordy, but tells me the that my system booted with, along with any other flags, which in my case is and : cmdline /proc /proc/cmdline initrd init loglevel cat /proc/cmdline initrd=\efi\nixos\hx5g5rmvq748m64r32yjmpjk3pmgqmr1-initrd-linux-5.17.11-initrd.efi init=/nix/store/9zvklk45yx41pak2hdxsxmmnq12n712k-nixos-system-diesel-22.05.20220604.d9794b0/init loglevel=4 My NixOS hostname is . Please note that I do not put petroleum in my laptop. diesel isn't just read-only, either. Like its man page says, is an to the kernel, which includes interacting with the kernel itself. The directory holds a variety of knobs and dials, but I want to show you , which lets us peek at the kernel's virtual memory. Want to get more adventurous? /proc /proc interface /proc/sys /proc/sys/vm Consider my machine's current memory usage. free -h total        used        free      shared  buff/cache   available
Mem:           31Gi        22Gi       3.0Gi       4.4Gi       5.6Gi       3.6Gi
Swap:          31Gi       130Mi        31Gi Nothing too unusual here – but what if I wanted to free up my memory aggressively? Most of the time, the kernel knows best when it comes to using memory for caching, but there are some situations in which you may want to clear any memory that is safe to clear – we don't want to break any running processes, just reclaim memory if possible. It turns out that there's a file for that. We pipe an command into because is usually write-protected and only can write to the file we're interested in. echo sudo tee /proc/sys/vm root echo 1 | sudo tee -a /proc/sys/vm/drop_caches What this command does is effectively signal to the kernel, "please drop any caches in memory that you can afford to lose without breaking any running processes on my system." On my machine this opens up about 500M of memory: total        used        free      shared  buff/cache   available
Mem:           31Gi        22Gi       3.5Gi       4.4Gi       5.1Gi       3.6Gi
Swap:          31Gi       130Mi        31Gi Cool! There are all sorts of useful file-like objects in that can do interesting things like this. Feel free to open up if you'd like to learn more. /proc man proc as a prehistoric /dev curl A character device like represents an attached disk, but there's another use for the path: a little-known way to send network requests. /dev/sda /dev The path isn't actually a file-like device exposed by the Linux kernel, but actually a feature of your chosen shell like . Shells can intercept operations on this path in order to open up low-level socket connections to remote endpoints like web servers listening on port . /dev/tcp bash 80 To begin, open a new file descriptor connected to a file path in that indicates the desired endpoint and port. Much like how file descriptor numbers 0, 1, and 2 represent , , and , respectively, you can think of this new file descriptor 3 as representing a pipe to a remote network endpoint. We'll assume the use of from here on out. /dev/tcp stdin stdout stderr bash exec 3<>/dev/tcp/httpbin.org/80 Next, send the plaintext form of a simple HTTP request to the open file descriptor. This request to also requires the header to be set in order to be properly handled by most reverse proxies. Two newlines signal termination of the request: GET /status/200 Host echo -e "GET /status/200 HTTP/1.1\r\nHost: httpbin.org\r\n\r\n" >&3 Finally, a simple read operation retrieves the HTTP response: cat <&3 You should see a response similar to the one below: HTTP/1.1 200 OK
Date: Fri, 10 Jun 2022 21:39:43 GMT
Content-Type: text/html; charset=utf-8
Content-Length: 0
Connection: keep-alive
Server: gunicorn/19.9.0
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true Congratulations! You've just sent an HTTP request using nothing but your shell. Swimming in /sys There's one more root-level directory to explore after diving into and : the enigmatic directory. /proc /dev /sys Like and , is another file-like interface to low-level mechanisms that sit very close to the operating system. Unlike - which is relatively process-focused - and - which models block devices and more - is a useful interface to many abstractions that the kernel models. /proc /dev /sys /proc /dev /sys For example, take the directory . Inside of this directory, you'll find a list of links that represent the network interfaces on your host. Here's what mine looks like: /sys/class/net ls /sys/class/net enp0s20f0u6u4u1
lo
tailscale0
wlan0 As you can see, the active network connections that my system is managing include a wired interface (the interface that begins with ), the loopback interface, a interface, and my wireless interface . Listing the contents of one of these directories reveals a long list of files, but let's look more closely at two files in particular for my wired network interface: en lo Tailscale wlan0 cat /sys/class/net/enp0s20f0u6u4u1/statistics/rx_bytes
cat /sys/class/net/enp0s20f0u6u4u1/statistics/tx_bytes 11281235262
274308842 Each of these files represents the number of received bytes and transmitted bytes, respectively. Check out how the numbers change if I use the same command a few seconds later: cat /sys/class/net/enp0s20f0u6u4u1/statistics/rx_bytes
cat /sys/class/net/enp0s20f0u6u4u1/statistics/tx_bytes 11289633209
274760138 Bigger numbers! Apparently I'm making the most of my bandwidth. How is this useful? Have you ever wondered how network usage widgets are written? Well, how about making your own? Check out this small script that uses the aforementioned files in the directory to derive a network activity rate. bash statistics interval=1
interface=$1

rx_bytes=$(cat /sys/class/net/$interface/statistics/rx_bytes)
tx_bytes=$(cat /sys/class/net/$interface/statistics/tx_bytes)

rx_bytes_rate=0
tx_bytes_rate=0

function fmt() {
  numfmt --to=iec-i --suffix=B $1
}

while true
do
        echo -en " $(fmt $tx_bytes_rate)/s ⬆ $(fmt $rx_bytes_rate)/s ⬇\t\r"
        sleep $interval
        old_rx_bytes=$rx_bytes
        old_tx_bytes=$tx_bytes
        rx_bytes=$(cat /sys/class/net/$interface/statistics/rx_bytes)
        tx_bytes=$(cat /sys/class/net/$interface/statistics/tx_bytes)
        tx_bytes_rate=$(( ($tx_bytes - $old_tx_bytes) / $interval ))
        rx_bytes_rate=$(( ($rx_bytes - $old_rx_bytes) / $interval ))
done You can place this script somewhere in your , make it executable with , and try it out with . Here's what the output looks like on my machine: $PATH chmod +x <script> script.sh <interface name> 13KiB/s ⬆  379KiB/s ⬇ That's pretty cool! You can imagine some uses for this: for example, as a widget for a tool that can render command output or as a quick way to look at network activity for a particular network interface. In either case, the file-based interface to this data makes accessing and using it exceptionally easy. Further Exploration This was just a small dive into the types of information available to you as you look further into the capabilities of a modern Linux system. You can search for additional guides like this one or go straight to the source by reading pages for entries like in order to read the function and purpose of various directories in . man man hier / Have fun exploring!

20,000 Leagues Under Your Shell

20.000 leguas bajo tu caparazón

20 000 lieues sous votre coquille

20,000 लीग अंडर योर शेल

シェルの下で 20,000 マイル

20.000 léguas sob sua concha

20.000 giải đấu dưới vỏ bọc của bạn

20,000 联赛在您的壳下

A Javascript object is a collection of properties and some member methods. Use the “.” symbol to operate property values. We know that the string is not an object, so why does it have properties? Because V8 converts a string into an object first when operating the properties of the string. The conversion is invisible to developers. But in V8, you can see the conversion detail and understand the source code of the String object. In this paper, we’ll talk about the conversion from a string to a string object. 1. String variable 1.var s = "hello world!";
2.var word = s.substring(s.indexOf(" ")+1,s.length);
3.console.log(word) Look at the above code, the string s is not an object, but when we call .indexOf(), V8 will convert s to a string object. Let’s talk about conversion from the following two questions. In the 1st line, let’s take a look at what type is? (1) s In the 2nd line, when we call .indexOf, how does V8 convert it to an object? (2) Look at the code below, which is the bytecode data of our case. 1.  [generated bytecode for function:  (0x03d78d381bd1 <SharedFunctionInfo>)]
2.  Parameter count 1
3.  Register count 6
4.  Frame size 48
5.           000003D78D381D06 @    0 : 12 00             LdaConstant [0]
6.           000003D78D381D08 @    2 : 26 fa             Star r1
7.           000003D78D381D0A @    4 : 0b                LdaZero
8.           000003D78D381D0B @    5 : 26 f9             Star r2
9.           000003D78D381D0D @    7 : 27 fe f8          Mov <closure>, r3
10.           000003D78D381D10 @   10 : 61 2d 01 fa 03    CallRuntime [DeclareGlobals], r1-r3
11.      0 E> 000003D78D381D15 @   15 : a7                StackCheck
12.      8 S> 000003D78D381D16 @   16 : 12 01             LdaConstant [1]
13.      8 E> 000003D78D381D18 @   18 : 15 02 04          StaGlobal [2], [4]
14.     36 S> 000003D78D381D1B @   21 : 13 02 00          LdaGlobal [2], [0]
15.           000003D78D381D1E @   24 : 26 f9             Star r2
16.     38 E> 000003D78D381D20 @   26 : 29 f9 03          LdaNamedPropertyNoFeedback r2, [3]
17.           000003D78D381D23 @   29 : 26 fa             Star r1
18.     48 E> 000003D78D381D25 @   31 : 13 02 00          LdaGlobal [2], [0]
19.           000003D78D381D28 @   34 : 26 f7             Star r4
20.     50 E> 000003D78D381D2A @   36 : 29 f7 04          LdaNamedPropertyNoFeedback r4, [4]
21.           000003D78D381D2D @   39 : 26 f8             Star r3
22.           000003D78D381D2F @   41 : 12 05             LdaConstant [5]
23.           000003D78D381D31 @   43 : 26 f6             Star r5
24.     50 E> 000003D78D381D33 @   45 : 5f f8 f7 02       CallNoFeedback r3, r4-r5
25.     62 E> 000003D78D381D37 @   49 : 40 01 06          AddSmi [1], [6]
26.           000003D78D381D3A @   52 : 26 f8             Star r3
27.     65 E> 000003D78D381D3C @   54 : 13 02 00          LdaGlobal [2], [0]
28.           000003D78D381D3F @   57 : 26 f7             Star r4
29.     67 E> 000003D78D381D41 @   59 : 29 f7 06          LdaNamedPropertyNoFeedback r4, [6]
30.           000003D78D381D44 @   62 : 26 f7             Star r4
31.  //....omit......
32.  Constant pool (size = 10)
33.  000003D78D381C71: [FixedArray] in OldSpace
34.   - map: 0x03ac45880169 <Map>
35.   - length: 10
36.             0: 0x03d78d381c11 <FixedArray[8]>
37.             1: 0x03d78d381b69 <String[#12]: hello world!>
38.             2: 0x03d78d381b51 <String[#1]: s>
39.             3: 0x02ed266ea9e9 <String[#9]: substring>
40.             4: 0x02ed266e8121 <String[#7]: indexOf>
41.             5: 0x006d3e183c21 <String[#1]:  >
42.             6: 0x03ac45884819 <String[#6]: length>
43.             7: 0x03ac45885301 <String[#4]: word>
44.             8: 0x02ed266f2441 <String[#7]: console>
45.             9: 0x02ed266f1a81 <String[#3]: log>
46.  Handler Table (size = 0) Before diving in, let’s take a look at a concept — constant pool(from lines 32 to 45), which is a string-type array generated during JavaScript compilation and used to store constants. The 37th line is the string and the 38th line code is the string s, these two lines are the variable s we are talking about. hello world! Let’s look at lines 12 and 13, LdaConstant loads the constant-pool[1] into the accumulator, and StaGlobal uses the constant-pool[2] as the name to store the accumulator. What is the meaning of these two lines? They are declaring the string variable s(var s = “hello world!”) for our case. Debug line 13 to find out how to store the value of variable in detail. If we can see how to store s, we can see his type incidentally. s After Debugging, we find the following code will be called. RUNTIME_FUNCTION(Runtime_StoreGlobalICNoFeedback_Miss) {
  HandleScope scope(isolate);
  DCHECK_EQ(2, args.length());
  // Runtime functions don't follow the IC's calling convention.
  Handle<Object> value = args.at(0);
  Handle<Name> key = args.at<Name>(1);

  // TODO(mythria): Replace StoreGlobalStrict/Sloppy with StoreNamed.
  StoreGlobalIC ic(isolate, Handle<FeedbackVector>(), FeedbackSlot(),
                   FeedbackSlotKind::kStoreGlobalStrict);
  RETURN_RESULT_OR_FAILURE(isolate, ic.Store(key, value));
}
//.................separation...................................
#define RETURN_RESULT_OR_FAILURE(isolate, call)      \
  do {                                               \
    Handle<Object> __result__;                       \
    Isolate* __isolate__ = (isolate);                \
    if (!(call).ToHandle(&__result__)) {             \
      DCHECK(__isolate__->has_pending_exception());  \
      return ReadOnlyRoots(__isolate__).exception(); \
    }                                                \
    DCHECK(!__isolate__->has_pending_exception());   \
    return *__result__;                              \
  } while (false) In the above code, the RETURN_RESULT_OR_FAILURE is a macro template. We go on with debugging the code and step into the WriteDataValue() which is below. void LookupIterator::WriteDataValue(Handle<Object> value,
                                    bool initializing_store) {
  DCHECK_EQ(DATA, state_);
  Handle<JSReceiver> holder = GetHolder<JSReceiver>();
  if (IsElement()) {
    Handle<JSObject> object = Handle<JSObject>::cast(holder);
    ElementsAccessor* accessor = object->GetElementsAccessor(isolate_);
    accessor->Set(object, number_, *value);
  } else if (holder->HasFastProperties(isolate_)) {
    if (property_details_.location() == kField) {
  //omit......................... In WriteDataValue, determine whether the parameter value is a global object. In our case, the value is our s apparently, which is a global object and meets the condition in Figure 1. Look at the green marks in Figure 1, the value is our , and its type is ONE_BYTE_INTERNALIZED_STRING, which solves question 1 exactly. hello world! 2. String object Let’s take a look at question 2, how to convert a string variable to an object. Our case is calling .substring(). In the bytecode array of the case, lines 14 and 15 have stored the variable s in register r2, line 16 needs to load .substring() for r2, and the below bytecode LdaNamedPropertyNoFeedback is responsible for loading properties. 1.  IGNITION_HANDLER(LdaNamedPropertyNoFeedback, InterpreterAssembler) {
2.    TNode<Object> object = LoadRegisterAtOperandIndex(0);
3.    TNode<Name> name = CAST(LoadConstantPoolEntryAtOperandIndex(1));
4.    TNode<Context> context = GetContext();
5.    TNode<Object> result =
6.        CallBuiltin(Builtins::kGetProperty, context, object, name);
7.    SetAccumulator(result);
8.    CallRuntime(Runtime::kDebugPrint, context, object, name,result);//This is the debug command I wrote,@huidou
9.    Dispatch();
10.  }
11.  //.........................separation.........................................
12.  TF_BUILTIN(GetProperty, CodeStubAssembler) {
13.    Node* object = Parameter(Descriptor::kObject);
14.    Node* key = Parameter(Descriptor::kKey);
15.    Node* context = Parameter(Descriptor::kContext);
16.    // TODO(duongn): consider tailcalling to GetPropertyWithReceiver(object,
17.    // object, key, OnNonExistent::kReturnUndefined).
18.    Label if_notfound(this), if_proxy(this, Label::kDeferred),
19.        if_slow(this, Label::kDeferred);
20.    CodeStubAssembler::LookupInHolder lookup_property_in_holder =
21.        [=](Node* receiver, Node* holder, Node* holder_map,
22.            Node* holder_instance_type, Node* unique_name, Label* next_holder,
23.            Label* if_bailout) {
24.          VARIABLE(var_value, MachineRepresentation::kTagged);
25.          Label if_found(this);
26.          TryGetOwnProperty(context, receiver, holder, holder_map,
27.                            holder_instance_type, unique_name, &if_found,
28.                            &var_value, next_holder, if_bailout);
29.          BIND(&if_found);
30.          Return(var_value.value());
31.        };
32.    CodeStubAssembler::LookupInHolder lookup_element_in_holder =
33.        [=](Node* receiver, Node* holder, Node* holder_map,
34.            Node* holder_instance_type, Node* index, Label* next_holder,
35.            Label* if_bailout) {
36.          // Not supported yet.
37.          Use(next_holder);
38.          Goto(if_bailout);
39.        };
40.    TryPrototypeChainLookup(object, object, key, lookup_property_in_holder,
41.                            lookup_element_in_holder, &if_notfound, &if_slow,
42.                            &if_proxy);
43.    BIND(&if_notfound);
44.    Return(UndefinedConstant());
45.    BIND(&if_slow);
46.    TailCallRuntime(Runtime::kGetProperty, context, object, key);
47.    BIND(&if_proxy);
48.    {
49.      // Convert the {key} to a Name first.
50.      TNode<Object> name = CallBuiltin(Builtins::kToName, context, key);
51.      // The {object} is a JSProxy instance, look up the {name} on it, passing
52.      // {object} both as receiver and holder. If {name} is absent we can safely
53.      // return undefined from here.
54.      TailCallBuiltin(Builtins::kProxyGetProperty, context, object, name, object,
55.                      SmiConstant(OnNonExistent::kReturnUndefined));
56.    }
57.  } In the process of debugging LdaNamedPropertyNoFeedback, we can only see the assembly code, but not the C++ source code. The bytecode is stored separately in the snapshot_blob file and loaded by V8 in the deserialized way without the symbol table, so we can’t see C++. The 8th line of code is my additional CallRuntime, which is used to return to the C++ environment for watching variables. Look at Figure 2. With the help of line 8, we can get back to the C++ environment. Here, we can only watch variables, not debug. We will return to the assembly environment if we do a step. Figure 3 is the call stack. To sum up, in Figure 2, the args[0] is ‘hello world!’, which is the global variable s declared before. Note that its type is still ONE_BYTE_INTERNALIZED_STRING. Let’s look at args[2], its type is JS_FUNCTION, which is the address of the substring() method. At this point, the operation is completed, and s is still a string. Actually, it doesn’t prevent V8 from calling the substring and returning the value. This is the implementation style of V8, the engineering method and technical principle may be dissimilar. . 3. Summary In v8, the String is subdivided into many subtypes which are below. switch (map.instance_type()) {
    case CONS_STRING_TYPE:
    case CONS_ONE_BYTE_STRING_TYPE:
    case THIN_STRING_TYPE:
    case THIN_ONE_BYTE_STRING_TYPE:
    case SLICED_STRING_TYPE:
    case SLICED_ONE_BYTE_STRING_TYPE:
    case EXTERNAL_STRING_TYPE:
    case EXTERNAL_ONE_BYTE_STRING_TYPE:
    case UNCACHED_EXTERNAL_STRING_TYPE:
    case UNCACHED_EXTERNAL_ONE_BYTE_STRING_TYPE:
    case STRING_TYPE:
    case ONE_BYTE_STRING_TYPE:
    //omit........................ When using .substring(), the variable is still a string. In the V8 implementation, the string is a heap-managed object, but as I’ve mentioned, its type is the string. s Below is the function I use to debug a bytecode, it is Runtime, and the usage is CallRuntime(Runtime::kDebugPrint, context, your args0, your args1….). You can see how I use it in the code above. 1.  RUNTIME_FUNCTION(Runtime_DebugPrint) {
2.    SealHandleScope shs(isolate);
3.    //DCHECK_EQ(1, args.length());
4.    MaybeObject maybe_object(*args.address_of_arg_at(0));
5.    StdoutStream os;
6.    if (maybe_object->IsCleared()) {
7.      os << "[weak cleared]";
8.    } else {
9.      Object object = maybe_object.GetHeapObjectOrSmi();
10.      bool weak = maybe_object.IsWeak();
11.  #ifdef DEBUG
12.      if (object.IsString() && !isolate->context().is_null()) {
13.        DCHECK(!weak);
14.        // If we have a string, assume it's a code "marker"
15.        // and print some interesting cpu debugging info.
16.        object.Print(os);
17.        JavaScriptFrameIterator it(isolate);
18.        JavaScriptFrame* frame = it.frame();
19.        os << "fp = " << reinterpret_cast<void*>(frame->fp())
20.           << ", sp = " << reinterpret_cast<void*>(frame->sp())
21.           << ", caller_sp = " << reinterpret_cast<void*>(frame->caller_sp())
22.           << ": ";
23.      } else {
24.        os << "DebugPrint: ";
25.        if (weak) {
26.          os << "[weak] ";
27.        }
28.        object.Print(os);
29.      }
30.      if (object.IsHeapObject()) {
31.        HeapObject::cast(object).map().Print(os);
32.      }
33.  #else
34.      if (weak) {
35.        os << "[weak] ";
36.      }
37.      // ShortPrint is available in release mode. Print is not.
38.      os << Brief(object);
39.  #endif
40.    }
41.    os << std::endl;
42.    return args[0];  // return TOS
43.  } By the way, you can also use the function in your JavaScript source via the option. allow-natives-syntax Okay, that wraps it up for this share. I’ll see you guys next time, take care! Please reach out to me if you have any issues. Also Published here

What is String Object Analysis in Chrome V8

Welcome to other chapters of Let’s Understand Chrome V8 Dispatch is responsible for scheduling bytecode, which is equivalent to registering EIP++, and jumps to the next bytecode. Dispatch consists of two parts, one is a dispatch table and the other is the physical register. The table is an array that contains all bytecode addresses. V8 uses the physical register to dispatch bytecode for getting greater efficiency. 1. Dispatch Table The dispatch table is an array of pointers, which is used to store the address of the bytecode processing program. The array type is Code, and the Code Class is below: class Code: public HeapObject {
    public: NEVER_READ_ONLY_SPACE
    using Flags = uint32_t;
    #define CODE_KIND_LIST(V)\
    V(OPTIMIZED_FUNCTION)\
    V(BYTECODE_HANDLER)\
    V(STUB)\
    V(BUILTIN)\
    V(REGEXP)\
    V(WASM_FUNCTION)\
    V(WASM_TO_CAPI_FUNCTION)\
    V(WASM_TO_JS_FUNCTION)\
    V(JS_TO_WASM_FUNCTION)\
    V(JS_TO_JS_FUNCTION)\
    V(WASM_INTERPRETER_ENTRY)\
    V(C_WASM_ENTRY)
    enum Kind {
      #define DEFINE_CODE_KIND_ENUM(name) name,
        CODE_KIND_LIST(DEFINE_CODE_KIND_ENUM)
      #undef DEFINE_CODE_KIND_ENUM
      NUMBER_OF_KINDS
    };
    static
    const char * Kind2String(Kind kind);
    #ifdef ENABLE_DISASSEMBLER
    const char * GetName(Isolate * isolate) const;
    V8_EXPORT_PRIVATE void Disassemble(const char * name, std::ostream & os,
      Address current_pc = kNullAddress);
    #endif
    //................omit................
  }; : In the isolate, there is another pointer array that is the same type as the dispatch table. It holds all the Builtins addresses, which can confuse beginners easily. Note The dispatch table is maintained by BuildWithMacroAssembler, code is below: Code BuildWithMacroAssembler(Isolate * isolate, int32_t builtin_index,
    MacroAssemblerGenerator generator,
    const char * s_name) {
    HandleScope scope(isolate);
    // Canonicalize handles, so that we can share constant pool entries pointing
    // to code targets without dereferencing their handles.
    CanonicalHandleScope canonical(isolate);
    constexpr int kBufferSize = 32 * KB;
    byte buffer[kBufferSize];
    MacroAssembler masm(isolate, BuiltinAssemblerOptions(isolate, builtin_index),
      CodeObjectRequired::kYes,
      ExternalAssemblerBuffer(buffer, kBufferSize));
    masm.set_builtin_index(builtin_index);
    DCHECK(!masm.has_frame());
    generator( & masm);
    int handler_table_offset = 0;
    // JSEntry builtins are a special case and need to generate a handler table.
    DCHECK_EQ(Builtins::KindOf(Builtins::kJSEntry), Builtins::ASM);
    DCHECK_EQ(Builtins::KindOf(Builtins::kJSConstructEntry), Builtins::ASM);
    DCHECK_EQ(Builtins::KindOf(Builtins::kJSRunMicrotasksEntry), Builtins::ASM);
    if (Builtins::IsJSEntryVariant(builtin_index)) {
      handler_table_offset = HandlerTable::EmitReturnTableStart( & masm);
      HandlerTable::EmitReturnEntry( &
        masm, 0, isolate -> builtins() -> js_entry_handler_offset());
    }
    //.....................................................
    //................omit.............................
  } You can see regarding how to debug the BuildWithMacroAssembler. When the value of the parameter builtin_index is 65, the function pointer generator points to which is responsible for maintaining the Dispatch table, code is below: Chapter 9 Generate_InterpreterEnterBytecodeDispatch static void Generate_InterpreterEnterBytecode(MacroAssembler * masm) {
    // Set the return address to the correct point in the interpreter entry
    // trampoline.
    Label builtin_trampoline, trampoline_loaded;
    Smi interpreter_entry_return_pc_offset(
      masm -> isolate() -> heap() -> interpreter_entry_return_pc_offset());
    DCHECK_NE(interpreter_entry_return_pc_offset, Smi::kZero);
    // If the SFI function_data is an InterpreterData, the function will have a
    // custom copy of the interpreter entry trampoline for profiling. If so,
    // get the custom trampoline, otherwise grab the entry address of the global
    // trampoline.
    __ movq(rbx, Operand(rbp, StandardFrameConstants::kFunctionOffset));
    __ LoadTaggedPointerField(
      rbx, FieldOperand(rbx, JSFunction::kSharedFunctionInfoOffset));
    __ LoadTaggedPointerField(
      rbx, FieldOperand(rbx, SharedFunctionInfo::kFunctionDataOffset));
    __ CmpObjectType(rbx, INTERPRETER_DATA_TYPE, kScratchRegister);
    __ j(not_equal, & builtin_trampoline, Label::kNear);
    __ movq(rbx,
      FieldOperand(rbx, InterpreterData::kInterpreterTrampolineOffset));
    __ addq(rbx, Immediate(Code::kHeaderSize - kHeapObjectTag));
    __ jmp( & trampoline_loaded, Label::kNear);
    __ bind( & builtin_trampoline);
    // TODO(jgruber): Replace this by a lookup in the builtin entry table.
    __ movq(rbx,
      __ ExternalReferenceAsOperand(
        ExternalReference::
        address_of_interpreter_entry_trampoline_instruction_start(
          masm -> isolate()),
        kScratchRegister));
    __ bind( & trampoline_loaded);
    __ addq(rbx, Immediate(interpreter_entry_return_pc_offset.value()));
    __ Push(rbx);
    // Initialize dispatch table register.
    __ Move(
      kInterpreterDispatchTableRegister,
      ExternalReference::interpreter_dispatch_table_address(masm -> isolate()));
    // Get the bytecode array pointer from the frame.
    __ movq(kInterpreterBytecodeArrayRegister,
      Operand(rbp, InterpreterFrameConstants::kBytecodeArrayFromFp));
    if (FLAG_debug_code) {
      // Check function data field is actually a BytecodeArray object.
      __ AssertNotSmi(kInterpreterBytecodeArrayRegister);
      __ CmpObjectType(kInterpreterBytecodeArrayRegister, BYTECODE_ARRAY_TYPE,
        rbx);
      __ Assert(
        equal,
        AbortReason::kFunctionDataShouldBeBytecodeArrayOnInterpreterEntry);
    }
    // Get the target bytecode offset from the frame.
    __ movq(kInterpreterBytecodeOffsetRegister,
      Operand(rbp, InterpreterFrameConstants::kBytecodeOffsetFromFp));
    __ SmiUntag(kInterpreterBytecodeOffsetRegister,
      kInterpreterBytecodeOffsetRegister);
    // Dispatch to the target bytecode.
    __ movzxbq(r11, Operand(kInterpreterBytecodeArrayRegister,
      kInterpreterBytecodeOffsetRegister, times_1, 0));
    __ movq(kJavaScriptCallCodeStartRegister,
      Operand(kInterpreterDispatchTableRegister, r11,
        times_system_pointer_size, 0));
    __ jmp(kJavaScriptCallCodeStartRegister);
  }
  //================================separation=========================
  void Builtins::Generate_InterpreterEnterBytecodeDispatch(MacroAssembler * masm) {
    Generate_InterpreterEnterBytecode(masm);
  } In the above code, the is the entry point of bytecode dispatch, and the is the key code that implements the bytecode dispatch. Here are two important concepts: Generate_InterpreterEnterBytecodeDispatch Generate_InterpreterEnterBytecode The is a Builtin and its index is 65. (The index may be dissimilar in different V8 versions) Generate_InterpreterEnterBytecodeDispatch V8 uses a physical register to manage the dispatch table, the name of the register is . Using the physical register can avoid the push and pop of the dispatch table frequently, to improve efficiency. kInterpreterDispatchTableRegister Here are the key lines of code： Line 35, loads the dispatch table to the A register. Line 37 of code, take out the table address from the isolate. The implementation of A is in the below three functions. (1) ExternalReference ExternalReference::interpreter_dispatch_table_address(
  Isolate * isolate) {
  return ExternalReference(isolate -> interpreter() -> dispatch_table_address());
}
interpreter::Interpreter * interpreter() const {
  return interpreter_;
}
Address dispatch_table_address() {
  return reinterpret_cast < Address > ( & dispatch_table_[0]);
} Line 39 takes out the bytecode array from the stack. (2) Line 51 takes out the offset of the target bytecode from the bytecode array. (3) Lines 56 and 58 calculate the target bytecode address and store the address in kJavaScriptCallCodeStartRegister. (4) Line 61 jumps to register kJavaScriptCallCodeStartRegister and executes bytecode. Figure 1 is the call stack. (5) 2. TailCall The Dispatch() is the last step in a bytecode, so its alias is the tail call. Let’s look at a few bytecodes： IGNITION_HANDLER(StaGlobal, InterpreterAssembler) {
    TNode < Context > context = GetContext();
    //omit..............
    Goto( & end);
    Bind( & no_feedback);
    CallRuntime(Runtime::kStoreGlobalICNoFeedback_Miss, context, value, name);
    Goto( & end);
    Bind( & end);
    Dispatch(); // !!! this is the tail call.
  }
  IGNITION_HANDLER(LdaContextSlot, InterpreterAssembler) {
    TNode < Context > context = CAST(LoadRegisterAtOperandIndex(0));
    TNode < IntPtrT > slot_index = Signed(BytecodeOperandIdx(1));
    TNode < Uint32T > depth = BytecodeOperandUImm(2);
    TNode < Context > slot_context = GetContextAtDepth(context, depth);
    TNode < Object > result = LoadContextElement(slot_context, slot_index);
    SetAccumulator(result);
    Dispatch(); //!!! here also is.
  }
  IGNITION_HANDLER(LdaImmutableContextSlot, InterpreterAssembler) {
    TNode < Context > context = CAST(LoadRegisterAtOperandIndex(0));
    TNode < IntPtrT > slot_index = Signed(BytecodeOperandIdx(1));
    TNode < Uint32T > depth = BytecodeOperandUImm(2);
    TNode < Context > slot_context = GetContextAtDepth(context, depth);
    TNode < Object > result = LoadContextElement(slot_context, slot_index);
    SetAccumulator(result);
    Dispatch(); //!!! here 
  } The above three bytecodes all end with Dispatch(). Below is the code of Dispatch: void InterpreterAssembler::Dispatch() {
    Comment("========= Dispatch");
    DCHECK_IMPLIES(Bytecodes::MakesCallAlongCriticalPath(bytecode_), made_call_);
    TNode < IntPtrT > target_offset = Advance();
    TNode < WordT > target_bytecode = LoadBytecode(target_offset);
    if (Bytecodes::IsStarLookahead(bytecode_, operand_scale_)) {
      target_bytecode = StarDispatchLookahead(target_bytecode);
    }
    DispatchToBytecode(target_bytecode, BytecodeOffset());
  } The 2nd line is the comment function. When debugging, we can use its output information to locate the execution position. The 4th line takes out the offset of the target(next) bytecode. The 5th line loads the target bytecode. The 9th line calls which calls eventually. DspatchToBytecode() DispatchToBytecodeHandlerEntry() void InterpreterAssembler::DispatchToBytecodeHandlerEntry(
  TNode < RawPtrT > handler_entry, TNode < IntPtrT > bytecode_offset) {
  // Propagate speculation poisoning.
  TNode < RawPtrT > poisoned_handler_entry =
    UncheckedCast < RawPtrT > (WordPoisonOnSpeculation(handler_entry));
  TailCallBytecodeDispatch(InterpreterDispatchDescriptor {},
    poisoned_handler_entry, GetAccumulatorUnchecked(),
    bytecode_offset, BytecodeArrayTaggedPointer(),
    DispatchTablePointer());
} In , parameter 1 is the target bytecode and 2 is the offset of the bytecode. Parameter 1 is used to load the bytecode handler and 2 is used to load operands. Then call , which is below: DispatchToBytecodeHandlerEntry TailCallBytecodeDispatch template < class...TArgs >
    void CodeAssembler::TailCallBytecodeDispatch(
      const CallInterfaceDescriptor & descriptor, TNode < RawPtrT > target,
        TArgs...args) {
      DCHECK_EQ(descriptor.GetParameterCount(), sizeof...(args));
      auto call_descriptor = Linkage::GetBytecodeDispatchCallDescriptor(
        zone(), descriptor, descriptor.GetStackParameterCount());
      Node * nodes[] = {
        target,
        args...
      };
      CHECK_EQ(descriptor.GetParameterCount() + 1, arraysize(nodes));
      raw_assembler() -> TailCallN(call_descriptor, arraysize(nodes), nodes);
    } In the above code, the 5th line creates the descriptor, as below: CallDescriptor * Linkage::GetBytecodeDispatchCallDescriptor(
    Zone * zone,
    const CallInterfaceDescriptor & descriptor,
      int stack_parameter_count) {
    const int register_parameter_count = descriptor.GetRegisterParameterCount();
    const int parameter_count = register_parameter_count + stack_parameter_count;
    DCHECK_EQ(descriptor.GetReturnCount(), 1);
    LocationSignature::Builder locations(zone, 1, parameter_count);
    locations.AddReturn(regloc(kReturnRegister0, descriptor.GetReturnType(0)));
    for (int i = 0; i < parameter_count; i++) {
      if (i < register_parameter_count) {
        // The first parameters go in registers.
        Register reg = descriptor.GetRegisterParameter(i);
        MachineType type = descriptor.GetParameterType(i);
        locations.AddParam(regloc(reg, type));
      } else {
        int stack_slot = i - register_parameter_count - stack_parameter_count;
        locations.AddParam(LinkageLocation::ForCallerFrameSlot(
          stack_slot, MachineType::AnyTagged()));
      }
    }
    MachineType target_type = MachineType::Pointer();
    LinkageLocation target_loc = LinkageLocation::ForAnyRegister(target_type);
    const CallDescriptor::Flags kFlags =
      CallDescriptor::kCanUseRoots | CallDescriptor::kFixedTargetRegister;
    return new(zone) CallDescriptor( // --
      CallDescriptor::kCallAddress, // kind
      target_type, // target MachineType
      target_loc, // target location
      locations.Build(), // location_sig
      stack_parameter_count, // stack_parameter_count
      Operator::kNoProperties, // properties
      kNoCalleeSaved, // callee-saved registers
      kNoCalleeSaved, // callee-saved fp
      kFlags, // flags
      descriptor.DebugName());
  } In , parameter 2 is the target bytecode, and parameter 3 is the stack parameter count. This function is used to apply for register resources and create a . The gives what parameters to supply when executing a bytecode. The comments on lines 24 to 25 give its layout. GetBytecodeDispatchCallDescriptor CallDescriptor CallDescriptor In , the on the 9th line is below, we see that it’s parameter 1 is . TailCallBytecodeDispatch TailCallN() CallDescriptor void RawMachineAssembler::TailCallN(CallDescriptor * call_descriptor,
    int input_count, Node *
    const * inputs) {
    // +1 is for target.
    DCHECK_EQ(input_count, call_descriptor -> ParameterCount() + 1);
    Node * tail_call =
      MakeNode(common() -> TailCall(call_descriptor), input_count, inputs);
    schedule() -> AddTailCall(CurrentBlock(), tail_call);
    current_block_ = nullptr;
  } The 5th line generates a node. In the 7th line adds the node to the end of the current basic block. So far, the dispatch is completed and the next bytecode is started to execute. Figure 2 shows the function call stack. AddTailCall() Okay, that wraps it up for this share. I’ll see you guys next time, take care! Please reach out to me if you have any issues. : qq9123013 : v8blink@outlook.com WeChat Email Also published . here

Stories, News & Mentions about TAILSCALE

Tailscale’s Stories on HackerNoon

Tailscale's News & Mentions