Rosetta 2 रिवर्स इंजीनियरिंग परियोजना

एप्पल की रोसेटा 2 बाइनरी अनुवाद तकनीक को समझने और दस्तावेज़ित करने का एक व्यापक रिवर्स-इंजीनियरिंग प्रयास।

विषय सूची

1. पृष्ठभूमि
2. रोसेटा क्या है?
3. रोसेटा 2 क्या है?
4. एप्पल मैकोज़ में रोसेटा 2 कैसे वितरित करता है
5. तकनीकी वास्तुकला
6. यह परियोजना
7. फ़ाइल संरचना
8. उपयोग
9. प्रगति
10. संदर्भ

पृष्ठभूमि

वास्तुकला परिवर्तन

नवंबर 2020 में, एप्पल ने अपने पहले Apple Silicon Macs की घोषणा की, जो Intel x86_64 प्रोसेसर से अपने स्वयं के ARM-आधारित M1 चिप्स की ओर एक ऐतिहासिक परिवर्तन था। यह एप्पल का तीसरा प्रमुख वास्तुकला परिवर्तन था:

1. 1994: Motorola 68000 -> PowerPC
2. 2006: PowerPC -> Intel x86_64
3. 2020: Intel x86_64 -> Apple Silicon (ARM64)

प्रत्येक परिवर्तन के दौरान मौजूदा सॉफ़्टवेयर को चलाने के लिए एक बाइनरी अनुवाद समाधान की आवश्यकता थी। रोसेटा 2 अब तक का एप्पल का सबसे उन्नत बाइनरी अनुवाद प्रणाली है।

रोसेटा क्या है?

रोसेटा (2006-2011) एप्पल का पहला गतिशील बाइनरी अनुवाद सॉफ़्टवेयर था, जिसने PowerPC अनुप्रयोगों को Intel-आधारित Macs पर चलने में सक्षम बनाया।

मुख्य विशेषताएं:

• गतिशील अनुवाद: PowerPC कोड को रनटाइम पर x86_64 में अनुवादित किया
• OS एकीकरण: Mac OS X 10.4 (Tiger) से 10.6 (Snow Leopard) में निर्मित
• पारदर्शी संचालन: उपयोगकर्ता PowerPC ऐप्स को सामान्य रूप से लॉन्च करते थे
• प्रदर्शन ओवरहेड: आमतौर पर नेटिव कोड की तुलना में 20-50% धीमा

रोसेटा को Mac OS X 10.7 (Lion) में हटा दिया गया, जिससे Intel परिवर्तन पूरा हुआ।

रोसेटा 2 क्या है?

रोसेटा 2 एप्पल की उन्नत गतिशील बाइनरी अनुवाद तकनीक है जो Intel x86_64 Macs के लिए संकलित अनुप्रयोगों को Apple Silicon (ARM64) Macs पर चलाने में सक्षम बनाती है।

वास्तुकला अवलोकन```

┌─────────────────────────────────────────────────────────────┐ │ User Application (x86_64) │ ├─────────────────────────────────────────────────────────────┤ │ Rosetta 2 Layer │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐ │ │ │ Translator │ │ Runtime │ │ System Call │ │ │ │ (AOT/JIT) │ │ Library │ │ Translation │ │ │ └─────────────┘ └─────────────┘ └─────────────────────┘ │ ├─────────────────────────────────────────────────────────────┤ │ macOS Kernel (ARM64) │ ├─────────────────────────────────────────────────────────────┤ │ Apple Silicon Hardware │ └─────────────────────────────────────────────────────────────┘

### मुख्य प्रौद्योगिकियाँ

1. **पूर्व-समय (AOT) अनुवाद**
   - स्थापना के समय x86_64 बाइनरी को ARM64 में अनुवाद करता है
   - बाद के तेज़ लॉन्च के लिए अनुवादित कोड को कैश में संग्रहीत करता है
   - शुद्ध JIT अनुवाद की तुलना में रनटाइम ओवरहेड कम करता है

2. **समय-समय पर (JIT) अनुवाद**
   - निष्पादन के दौरान ऑन-डिमांड कोड ब्लॉक का अनुवाद करता है
   - डायनामिक रूप से लोड किए गए कोड और स्व-संशोधित कोड को संभालता है
   - दक्षता के लिए अनुवाद कैश बनाए रखता है

3. **निर्देश सेट अनुवाद**
   - x86_64 -> ARM64 निर्देश मैपिंग
   - SSE/AVX -> NEON वेक्टर निर्देश अनुवाद
   - x86_64 फ़्लैग -> ARM64 स्थिति कोड

4. **सिस्टम कॉल अनुवाद**
   - x86_64 macOS syscalls को ARM64 समकक्ष में अनुवाद करता है
   - विभिन्न कॉलिंग कन्वेंशन को संभालता है
   - syscall सीमाओं के पार रजिस्टर स्थिति का प्रबंधन करता है

5. **रनटाइम समर्थन**
   - CPU सुविधा पहचान एमुलेशन
   - थ्रेड-लोकल स्टोरेज हैंडलिंग
   - सिग्नल और अपवाद हैंडलिंग

---

## Apple macOS में Rosetta 2 कैसे प्रदान करता है

### स्थापना स्थान

Rosetta 2 यहाँ स्थित है:```
/Library/Apple/usr/libexec/oah/
├── rosetta        # Main translator binary
├── rosettad       # Rosetta daemon
└── librosetta.*   # Runtime libraries

oah निर्देशिका का अर्थ है "पुराने आर्किटेक्चर हार्डवेयर" - यह PowerPC संक्रमण युग की निरंतरता है।

स्वचालित स्थापना

Apple Silicon Macs पर, Rosetta 2 डिफ़ॉल्ट रूप से स्थापित नहीं होता है। इसे दो तरीकों से ट्रिगर किया जाता है:

1. पहली लॉन्च प्रॉम्प्ट ``` The "Rosetta" software is not installed on your Mac. Rosetta translates apps from Intel-based Macs for use on Apple Silicon Macs.
   root@kitploit:~

2. कमांड-लाइन इंस्टॉलेशन ```bash softwareupdate --install-rosetta --agree-to-license
   root@kitploit:~

वितरित किए गए घटक

macOS के साथ एकीकरण

1. launchd एकीकरण: Rosetta डेमॉन एक सिस्टम सेवा के रूप में चलता है
2. कोड हस्ताक्षर: अनुवादित बाइनरी स्वचालित रूप से कोड-हस्ताक्षरित होती हैं
3. गेटकीपर: Rosetta-अनुवादित ऐप्स सुरक्षा जांच पास करते हैं
4. सिस्टम अखंडता संरक्षण: संशोधन से संरक्षित

तकनीकी आर्किटेक्चर

अनुवाद प्रक्रिया```

┌──────────────────────────────────────────────────────────────────┐ │ Phase 1: Binary Loading │ │ ─────────────────────────────────────────────────────────────── │ │ 1. Load x86_64 Mach-O binary │ │ 2. Parse segments, sections, symbols │ │ 3. Validate code signatures │ │ 4. Map into translation context │ └──────────────────────────────────────────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────────────────────────────┐ │ Phase 2: AOT Translation │ │ ─────────────────────────────────────────────────────────────── │ │ 1. Disassemble x86_64 code sections │ │ 2. Translate instructions to ARM64 │ │ 3. Apply optimizations │ │ 4. Store in translation cache (~/.oah) │ └──────────────────────────────────────────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────────────────────────────┐ │ Phase 3: Runtime Execution │ │ ─────────────────────────────────────────────────────────────── │ │ 1. Load translated ARM64 code │ │ 2. Set up x86_64 emulation context │ │ 3. Handle JIT translations for dynamic code │ │ 4. Translate syscalls on-the-fly │ └──────────────────────────────────────────────────────────────────┘

### मुख्य अनुवाद चुनौतियाँ

1. **रजिस्टर मैपिंग**
   - x86_64 में 16 GPRs हैं; ARM64 में 31 GPRs हैं
   - x86_64 फ्लैग्स रजिस्टर -> ARM64 NZCV फ्लैग्स
   - RIP (निर्देश पॉइंटर) एमुलेशन

2. **मेमोरी ऑर्डरिंग**
   - x86_64: मजबूत मेमोरी ऑर्डरिंग (TSO)
   - ARM64: कमजोर मेमोरी ऑर्डरिंग
   - शुद्धता के लिए मेमोरी बैरियर्स की आवश्यकता

3. **वेक्टर निर्देश**
   - SSE (128-बिट) -> NEON (128-बिट) प्रत्यक्ष मैपिंग
   - AVX (256-बिट) -> NEON जोड़ी एमुलेशन
   - SIMD के लिए अलग अपवाद हैंडलिंग

4. **कॉलिंग कन्वेंशन्स**
   - x86_64: पहले 6 आर्गुमेंट्स रजिस्टरों में (RDI, RSI, RDX, RCX, R8, R9)
   - ARM64: पहले 8 आर्गुमेंट्स रजिस्टरों में (X0-X7)
   - अलग स्टैक फ्रेम लेआउट

---

## यह प्रोजेक्ट

यह रिपॉजिटरी Rosetta 2 बाइनरीज़ से फंक्शन्स के रिवर्स-इंजीनियर्ड कार्यान्वयन शामिल करती है। सावधानीपूर्वक विश्लेषण और डीकंपाइलेशन के माध्यम से, हमने सैकड़ों फंक्शन्स के सिमैंटिक उद्देश्य की पहचान की है और दस्तावेज़ीकृत किया है।

### लक्ष्य

1. **शैक्षिक**: Rosetta 2 आंतरिक रूप से कैसे काम करता है, इसे समझना
2. **दस्तावेज़ीकरण**: अनुवाद तकनीकों का व्यापक दस्तावेज़ीकरण बनाना
3. **कार्यान्वयन**: स्वच्छ, अच्छी तरह से दस्तावेज़ीकृत C कार्यान्वयन प्रदान करना
4. **समुदाय**: रिवर्स-इंजीनियरिंग समुदाय के साथ ज्ञान साझा करना

### हमने क्या हासिल किया है

- **828 फंक्शन्स** मुख्य `rosetta` बाइनरी में पहचाने और नामित किए गए
- **612 फंक्शन्स** स्वच्छ C कोड के साथ पूरी तरह से कार्यान्वित
- **66 श्रेणियाँ** कार्यक्षमता की दस्तावेज़ीकृत
- सिमैंटिक नामों के साथ पूर्ण फंक्शन नाम मैपिंग

### फंक्शन्स की श्रेणियाँ

| श्रेणी | फंक्शन्स | विवरण |
|----------|-----------|-------------|
| एंट्री पॉइंट | 1 | Rosetta आरंभीकरण |
| FP/वेक्टर संचालन | ~20 | फ्लोटिंग-पॉइंट और SIMD स्थिति प्रबंधन |
| SIMD मेमोरी संचालन | ~10 | SIMD के साथ memchr, memcmp, memcpy |
| वेक्टर संचालन | ~30 | NEON वेक्टर अंकगणित, तुलना |
| बाइनरी अनुवाद | ~50 | x86_64 -> ARM64 निर्देश अनुवाद |
| सिस्टम कॉल हैंडलर | ~60 | सिस्टम कॉल अनुवाद और अग्रेषण |
| मेमोरी प्रबंधन | ~20 | malloc, free, mmap रैपर |
| हैश फंक्शन्स | ~5 | अनुवाद कैश के लिए पता हैशिंग |
| स्ट्रिंग संचालन | ~30 | SIMD-अनुकूलित स्ट्रिंग फंक्शन्स |
| क्रिप्टोग्राफिक एक्सटेंशन | ~30 | AES, SHA, CRC32 पासथ्रू |
| ELF पार्सिंग | ~15 | लिनक्स बाइनरी प्रारूप समर्थन |
| अनुवाद कैश | ~20 | AOT/JIT कैश प्रबंधन |

---

## फ़ाइल संरचना

### मुख्य फ़ाइलें```
Rosetta2/
├── README.md                      # This file
├── rosetta_decomp.c               # Original decompilation (74,677 lines)
├── rosettad_decomp.c              # Daemon decompilation (44,064 lines)
├── rosetta_refactored.c           # Minimal wrapper (59 lines) - includes modular headers
├── rosetta_refactored.c.legacy    # Legacy refactored code (19,302 lines) - archived
├── rosetta_refactored.h           # Main header (1,215 lines)
├── rosetta_refactored_complete.c  # Single-file implementation (2,686 lines)
├── rosetta_function_map.h         # Function name mapping (828 functions)
├── rosettad_refactored.c          # Daemon-side refactoring
└── SESSION_*.md                   # Session logs (30+ sessions)

Modular Translation Infrastructure (56 C files + 65 H files)

अनुवाद अवसंरचना पूरी तरह से वर्गीकृत घटकों में मॉड्यूलराइज़ की गई है:``` ├── rosetta_types.h # Base type definitions ├── rosetta_x86_decode.h/.c # x86 decoder ├── rosetta_arm64_emit.h/.c # ARM64 emitter ├── rosetta_translate_alu.h/.c # ALU translations ├── rosetta_translate_memory.h/.c # Memory translations ├── rosetta_translate_branch.h/.c # Branch translations ├── rosetta_translate_bit.h/.c # Bit manipulation ├── rosetta_translate_string.h/.c # String operations ├── rosetta_translate_special.h/.c # Special instructions ├── rosetta_translate_block.h/.c # Block translation coordinator ├── rosetta_translate_dispatch.h/.c # Instruction dispatch ├── rosetta_trans_dispatch.h/.c # Main dispatch layer ├── rosetta_trans_alu.h/.c # ALU emulation layer ├── rosetta_trans_mem.h/.c # Memory emulation layer ├── rosetta_trans_branch.h/.c # Branch emulation layer ├── rosetta_trans_bit.h/.c # Bit emulation layer ├── rosetta_trans_string.h/.c # String emulation layer ├── rosetta_trans_special.h/.c # Special instruction emulation ├── rosetta_trans_system.h/.c # System instruction emulation ├── rosetta_trans_neon.h/.c # NEON emulation layer └── Makefile.modular # Modular build system

### कार्यात्मक मॉड्यूल

मुख्य बुनियादी ढांचा और सहायता मॉड्यूल:```
├── rosetta_jit.h/.c               # JIT compilation infrastructure
├── rosetta_exec.h/.c              # Execution engine (NEW)
├── rosetta_init.h/.c              # Initialization & FP registers (NEW)
├── rosetta_codegen.h/.c           # Code generation primitives
├── rosetta_cache.h/.c             # Translation cache (AOT/JIT)
├── rosetta_transcache.h/.c        # Translation cache management
├── rosetta_context.h/.c           # CPU context management
├── rosetta_runtime.h/.c           # Runtime support
├── rosetta_hash.h/.c              # Address hashing
├── rosetta_memmgmt.h/.c           # Memory management
├── rosetta_memory_utils.h/.c      # Memory utilities
├── rosetta_utils.h/.c             # Utility functions
├── rosetta_string_utils.h/.c      # String utilities
├── rosetta_trans_helpers.h/.c     # Translation helpers
├── rosetta_refactored_helpers.h/.c # Refactoring helpers
└── rosetta_refactored_types.h     # Refactored type definitions

SIMD/वेक्टर मॉड्यूल

SIMD और वेक्टर संचालन मॉड्यूल:``` ├── rosetta_simd.h/.c # SIMD operations ├── rosetta_simd_mem.h/.c # SIMD memory operations ├── rosetta_simd_mem_helpers.h/.c # SIMD memory helpers ├── rosetta_vector.h/.c # Vector operations ├── rosetta_refactored_vector.h/.c # Refactored vector ops ├── rosetta_jit_emit.h/.c # JIT emission ├── rosetta_jit_emit_simd.h/.c # SIMD JIT emission ├── rosetta_fp_translate.h/.c # FP translation ├── rosetta_fp_helpers.h/.c # FP helpers ├── rosetta_trans_neon.c # NEON translation └── rosetta_string_simd.c # SIMD string operations

### Syscall Modules

अतिथि syscall हैंडलिंग और अनुवाद:```
├── rosetta_syscalls.h/.c          # Syscall translation core
├── rosetta_syscalls_impl.h/.c     # Syscall implementations
└── rosetta_crypto.h/.c            # Crypto instructions (AES, SHA, CRC32)

अतिरिक्त मॉड्यूल

अतिरिक्त अनुवाद और समर्थन मॉड्यूल:``` ├── rosetta_translate.h/.c # Translation core ├── rosetta_translate_alu_impl.h/.c # ALU implementation details ├── rosetta_translate_memory_impl.h/.c # Memory implementation details ├── rosetta_translate_branch_impl.h/.c # Branch implementation details ├── rosetta_translate_special_impl.h/.c # Special implementation details └── rosetta_arm64_insns.h # ARM64 instruction definitions

### परीक्षण फ़ाइलें```
├── test_jit.c                     # JIT unit tests (737 lines)
└── test_translate.c               # Translation tests (1,059 lines)

कुल: 50+ स्रोत फ़ाइलें, ~150,000+ कोड की पंक्तियाँ

बिल्ड सिस्टम

पूर्वापेक्षाएँ

• C11 समर्थन के साथ GCC या Clang
• macOS या Linux (POSIX-संगत सिस्टम)

लाइब्रेरी का निर्माण```bash

Build static library using modular Makefile

make -f Makefile.modular all

This creates librosetta.a static library

### व्यक्तिगत घटकों का निर्माण```bash
# Compile core modules
gcc -c -I. -std=c11 rosetta_types.h
gcc -c -I. -std=c11 rosetta_codegen.c
gcc -c -I. -std=c11 rosetta_jit.c
gcc -c -I. -std=c11 rosetta_x86_decode.c
gcc -c -I. -std=c11 rosetta_arm64_emit.c

# Compile translation modules
gcc -c -I. -std=c11 rosetta_translate_alu.c
gcc -c -I. -std=c11 rosetta_translate_memory.c
gcc -c -I. -std=c11 rosetta_translate_branch.c
gcc -c -I. -std=c11 rosetta_translate_block.c
gcc -c -I. -std=c11 rosetta_translate_dispatch.c

# Compile support modules
gcc -c -I. -std=c11 rosetta_cache.c
gcc -c -I. -std=c11 rosetta_context.c
gcc -c -I. -std=c11 rosetta_syscalls.c
gcc -c -I. -std=c11 rosetta_runtime.c

परीक्षण चलाना```bash

Build and run JIT tests

make -f Makefile.modular test_jit

Build and run translation tests

make -f Makefile.modular test_translate

### लाइब्रेरी के रूप में उपयोग करना```bash
# Link against the static library
gcc -o my_app my_app.c -L. -lrosetta

# Or compile with source files directly
gcc -I. -o my_app my_app.c rosetta_*.c

डीकंपाइल्ड सोर्स फ़ाइल विश्लेषण

मूल डीकंपाइल्ड फ़ाइल rosetta_decomp.c में स्ट्रिंग लिटरल हैं जो मूल सोर्स कोड संरचना को प्रकट करते हैं। ये फ़ाइल नाम पूरे बाइनरी में एसर्शन/एरर संदेशों में दिखाई देते हैं।

नोट: रीफ़ैक्टर्ड कोड मूल की तुलना में एक भिन्न, अधिक मॉड्यूलर संरचना का उपयोग करता है।

हैडर फ़ाइलें (.h)

• Register.h
• TaggedPointer.h
• RedBlackTree.h
• TransactionalList.h
• Translator.h
• AssemblerBuffer.h
• BuilderBase.h
• IrBuilder_x86.h

C++ सोर्स फ़ाइलें (.cpp)

• Repatch.cpp
• Decoder.cpp
• Fixup.cpp
• AssemblerHelpers.cpp
• Operand.cpp
• Opcode.cpp
• BasicBlock.cpp
• ThreadContextFcntl.cpp
• InitStack.cpp
• Thread.cpp
• ThreadContext.cpp
• ThreadContextRuntimeSignals.cpp
• ThreadContextVm.cpp
• VMAllocationTracker.cpp

C++ हैडर फ़ाइलें (.hpp)

• AssemblerBase.hpp
• TranslatorBase.hpp

प्रगति

वर्तमान स्थिति

मॉड्यूलर आर्किटेक्चर (पूर्ण)

अनुवाद बुनियादी ढाँचा निम्नलिखित घटकों में पूरी तरह से मॉड्यूलराइज़्ड है:

कुल: 40+ मॉड्यूलर घटक

अनुवाद कवरेज

हाल के सत्र

संदर्भ

आधिकारिक Apple दस्तावेज़ीकरण

• अपने macOS ऐप्स को Apple Silicon पर पोर्ट करना
• आर्किटेक्चर अंतरों को संबोधित करना

तकनीकी संसाधन

• ARM64 सिस्टम V ABI
• Intel 64 and IA-32 Architectures SDM
• ARM आर्किटेक्चर संदर्भ पुस्तिका

संबंधित परियोजनाएँ

• FEX-Emu - Linux x86_64 ऑन ARM64 एमुलेटर
• QEMU - सामान्य मशीन एमुलेटर
• Rosetta Linux - सामुदायिक अनुसंधान परियोजना

अस्वीकरण

यह परियोजना केवल शैक्षिक और अनुसंधान उद्देश्यों के लिए है।

• Rosetta 2 मालिकाना Apple सॉफ़्टवेयर है
• यह परियोजना Apple के बाइनरी वितरित नहीं करती
• इस रिपॉजिटरी में सभी कोड Claude Code द्वारा Qwen 3.5 के साथ लिखा गया है।
• Apple के सुरक्षा उपायों को दरकिनार करने के लिए इस परियोजना का उपयोग न करें

लाइसेंस

MIT लाइसेंस - विवरण के लिए LICENSE फ़ाइल देखें।

योगदान

योगदान का स्वागत है! रुचि के क्षेत्र:

1. शेष फ़ंक्शनों को कार्यान्वित करना
2. दस्तावेज़ीकरण में सुधार करना
3. परीक्षण मामले जोड़ना
4. प्रदर्शन विश्लेषण
5. आर्किटेक्चर आरेख

अंतिम अद्यतन: फरवरी 2026