C Language
इनलाइन असेंबली

टिप्पणियों

gcc बेसिक asm सपोर्ट

Gcc के साथ मूल असेंबली समर्थन में निम्नलिखित सिंटैक्स है:

asm [ volatile ] ( AssemblerInstructions )

जहाँ AssemblerInstructions दिए गए प्रोसेसर के लिए डायरेक्ट असेंबली कोड है। वाष्पशील खोजशब्द वैकल्पिक है और इसका कोई प्रभाव नहीं है क्योंकि gcc एक मूल asm कथन में कोड का अनुकूलन नहीं करता है। AssemblerInstructions में कई असेंबली निर्देश हो सकते हैं। यदि आप एक asm दिनचर्या है कि एक सी समारोह के बाहर मौजूद होना चाहिए एक बुनियादी asm बयान का उपयोग किया जाता है। निम्न उदाहरण जीसीसी मैनुअल से है:

 /* Note that this code will not compile with -masm=intel */
 #define DebugBreak() asm("int $3")

इस उदाहरण में, आप फिर अपने कोड में अन्य स्थानों पर DebugBreak() उपयोग कर सकते हैं और यह असेंबली इंस्ट्रक्शन int $3 को निष्पादित करेगा। ध्यान दें कि भले ही gcc एक बुनियादी asm स्टेटमेंट में किसी भी कोड को संशोधित नहीं करेगा, लेकिन ऑप्टिमाइज़र अभी भी लगातार asm स्टेटमेंट को इधर-उधर कर सकता है। यदि आपके पास कई विधानसभा निर्देश हैं जो एक विशिष्ट क्रम में होने चाहिए, तो उन्हें एक asm विवरण में शामिल करें।

जीसीसी विस्तारित asm समर्थन

Gcc में विस्तारित asm समर्थन में निम्नलिखित सिंटैक्स है:

asm [volatile] ( AssemblerTemplate
                  : OutputOperands
                  [ : InputOperands
                  [ : Clobbers ] ])
 
 asm [volatile] goto ( AssemblerTemplate
                       :
                       : InputOperands
                       : Clobbers
                       : GotoLabels)

जहां AssemblerTemplate कोडांतरक शिक्षा के लिए टेम्पलेट है, OutputOperands किसी भी सी चर कि विधानसभा कोड के द्वारा संशोधित किया जा सकता है, InputOperands किसी भी सी इनपुट पैरामीटर के रूप में इस्तेमाल चर हैं, Clobbers सूची या रजिस्टर कि विधानसभा कोड से संशोधित कर रहे हैं कर रहे हैं, और GotoLabels असेंबली कोड में किसी भी गोटो स्टेटमेंट लेबल का उपयोग किया जा सकता है।

विस्तारित प्रारूप का उपयोग C फ़ंक्शन के भीतर किया जाता है और इनलाइन असेंबली का अधिक विशिष्ट उपयोग है। नीचे लिनक्स कर्नेल से 16-बिट और एआरएम प्रोसेसर के लिए 32-बिट संख्या को स्वैप करने के लिए एक उदाहरण है:

/* From arch/arm/include/asm/swab.h in Linux kernel version 4.6.4 */
#if __LINUX_ARM_ARCH__ >= 6

static inline __attribute_const__ __u32 __arch_swahb32(__u32 x)
{
    __asm__ ("rev16 %0, %1" : "=r" (x) : "r" (x));
    return x;
}
#define __arch_swahb32 __arch_swahb32
#define __arch_swab16(x) ((__u16)__arch_swahb32(x))

static inline __attribute_const__ __u32 __arch_swab32(__u32 x)
{
    __asm__ ("rev %0, %1" : "=r" (x) : "r" (x));
    return x;
}
#define __arch_swab32 __arch_swab32

#endif

प्रत्येक asm खंड इसके इनपुट और आउटपुट पैरामीटर के रूप में चर x का उपयोग करता है। C फ़ंक्शन तब हेरफेर किए गए परिणाम देता है।

विस्तारित asm प्रारूप के साथ, gcc असेंब ब्लॉक में असेंबली निर्देशों का अनुकूलन उसी नियम के अनुसार कर सकता है जो C कोड को अनुकूलित करने के लिए उपयोग करता है। यदि आप चाहते हैं कि आपका asm सेक्शन अछूता रहे, तो asm सेक्शन के लिए volatile कीवर्ड का उपयोग करें।

मैक्रोस में gcc इनलाइन असेंबली

हम एक मैक्रो के अंदर असेंबली निर्देश डाल सकते हैं और मैक्रो का उपयोग कर सकते हैं जैसे आप एक फ़ंक्शन को कॉल करेंगे।

#define mov(x,y) \
{ \
    __asm__ ("l.cmov %0,%1,%2" : "=r" (x) : "r" (y), "r" (0x0000000F)); \
}

/// some definition and assignment
unsigned char sbox[size][size];
unsigned char sbox[size][size];

///Using
mov(state[0][1], sbox[si][sj]);

C कोड में एम्बेडेड इनलाइन असेंबली निर्देशों का उपयोग करने से प्रोग्राम के रन टाइम में सुधार हो सकता है। यह क्रिप्टोग्राफिक एल्गोरिदम जैसे एईएस जैसी महत्वपूर्ण परिस्थितियों में बहुत मददगार है। उदाहरण के लिए, एईएस एल्गोरिथ्म में एक सरल पारी ऑपरेशन की आवश्यकता होती है, हम सी शिफ्ट सिस्टम >> साथ डायरेक्ट Rotate Right असेंबली इंस्ट्रक्शन को स्थानापन्न कर सकते हैं।

'AES256' के कार्यान्वयन में, 'AddRoundKey ()' फ़ंक्शन में हमारे पास कुछ कथन हैं:

unsigned int w;          // 32-bit
unsigned char subkey[4]; // 8-bit, 4*8 = 32 

subkey[0] = w >> 24;     // hold 8 bit, MSB, leftmost group of 8-bits 
subkey[1] = w >> 16;     // hold 8 bit, second group of 8-bit from left    
subkey[2] = w >> 8;      // hold 8 bit, second group of 8-bit from right
subkey[3] = w;           // hold 8 bit, LSB, rightmost group of 8-bits

/// subkey <- w

वे बस w से subkey सरणी में बिट का मान प्रदान करते हैं।

हम तीन बदलाव + असाइन कर सकते हैं और एक असाइनमेंट C अभिव्यक्ति केवल एक असेंबली Rotate Right ऑपरेशन के साथ।

__asm__ ("l.ror  %0,%1,%2" : "=r" (* (unsigned int *) subkey)  : "r" (w), "r" (0x10));

अंतिम परिणाम बिल्कुल वही है।