सवाल कैसे बताएं कि एक लिनक्स सिस्टम बड़ा एंडियन या छोटा एंडियन है या नहीं?


मुझे पता है कि कुछ प्रोसेसर बिग एंडियन हैं और अन्य लिटिल एंडियन हैं। लेकिन क्या कोई कमांड, बैश स्क्रिप्ट, पायथन स्क्रिप्ट या कमांड की श्रृंखला है जिसे कमांड लाइन पर इस्तेमाल किया जा सकता है यह निर्धारित करने के लिए कि कोई सिस्टम बिग एंडियन या लिटिल एंडियन है या नहीं? कुछ इस तरह:

if <some code> then
    echo Big Endian
else
    echo Little Endian
fi

या यह निर्धारित करना अधिक आसान है कि सिस्टम किस प्रोसेसर का उपयोग कर रहा है और इसके अंतहीनता को निर्धारित करने के लिए इसके साथ जाना है?


82
2017-07-23 16:58


मूल


पेर्ल का उपयोग कर समाधान यहां दिया गया है: stackoverflow.com/questions/2610849/... - slu


जवाब:


एक बिग एंडियन-सिस्टम पर (एसपीएआरसी पर सोलारिस)

$ echo -n I | od -to2 | head -n1 | cut -f2 -d" " | cut -c6 

0

एक छोटी एंडियन प्रणाली पर (x86 पर लिनक्स)

$ echo -n I | od -to2 | head -n1 | cut -f2 -d" " | cut -c6 

1


उपरोक्त समाधान चालाक है और लिनक्स * 86 और सोलारिस स्पार्क के लिए बहुत अच्छा काम करता है।

मुझे एक शेल-केवल (कोई पर्ल) समाधान की आवश्यकता नहीं थी जिसने एईक्स / पावर और एचपीयूएक्स / इटेनियम पर भी काम किया। दुर्भाग्यवश आखिरी दो अच्छा नहीं खेलते: एईक्स रिपोर्ट "6" और एचपीयूएक्स एक खाली रेखा देता है।

अपने समाधान का उपयोग करके, मैं इन सभी यूनिक्स सिस्टम पर काम करने वाली कुछ चीज तैयार करने में सक्षम था:

$ echo I | tr -d [:space:] | od -to2 | head -n1 | awk '{print $2}' | cut -c6

किसी को पोस्ट किए गए पायथन समाधान के बारे में, यह ज्योथन में काम नहीं करता है क्योंकि जेवीएम सबकुछ बिग के रूप में व्यवहार करता है। यदि कोई इसे ज्योथन में काम करने के लिए प्राप्त कर सकता है, तो कृपया पोस्ट करें!

इसके अलावा, मैंने यह पाया, जो विभिन्न प्लेटफार्मों की अंतहीनता बताता है। ओ / एस का चयन करने के आधार पर कुछ हार्डवेयर किसी भी मोड में काम कर सकते हैं: http://labs.hoffmanlabs.com/node/544


यदि आप अजीब का उपयोग करने जा रहे हैं तो इस लाइन को सरल बनाया जा सकता है:

echo -n I | od -to2 | awk '{ print substr($2,6,1); exit}'

छोटे लिनक्स बॉक्स के लिए जिनके पास 'od' नहीं है (OpenWrt कहें) फिर 'हेक्सडम्प' आज़माएं:

echo -n I | hexdump -o | awk '{ print substr($2,6,1); exit}'

102
2017-07-23 17:04



यह एक ऊपरी मामला है I (आंख) एक निचले मामले के बजाय l (ell) रास्ते से। - Dennis Williamson
(सोलारिस) -> (सोलारिस, स्पार्क), हालांकि स्पार्क> = वी 9 द्वि एंडियन है। - Cristian Ciupitu
यह समझाने की देखभाल कि यह कैसे काम करता है? - Massimo
यह एंड्रॉइड (नेक्सस 5) पर काम नहीं कर रहा है। यकीन नहीं है कि क्यों... - wjandrea
printf "\x1" | od -to2 | awk 'NR==1{print$2==1}' - Kaz


यहां एक और सुरुचिपूर्ण पायथन एक-पंक्ति लिपि है

python -c "import sys;sys.exit(0 if sys.byteorder=='big' else 1)"

बाहर निकलें कोड 0 मतलब बड़ा एंडियन और 1 मतलब थोड़ा प्यारा है

या बस बदलें sys.exit सेवा मेरे print एक प्रिंट करने योग्य आउटपुट के लिए


29
2018-05-21 20:26



यह RHEL 5.x / CentOS 5.x सिस्टम पर काम नहीं करेगा जो Python 2.4.x चला रहे हैं। यहां एक फिक्स है: python -c "import sys;sys.exit(int(sys.byteorder!='big'))" - JPaget


यदि आप हाल ही में लिनक्स मशीन पर हैं (2012 के बाद कुछ भी) फिर lscpu अब यह जानकारी है:

$ lscpu | grep Endian
Byte Order:            Little Endian

इसमें जोड़ा गया था lscpu संस्करण 2.1 9 में, जो Fedora> = 17, CentOS> = 6.0, उबंटू> = 12.04 में पाया जाता है।

ध्यान दें कि मुझे यह जवाब मिला है Unix.SE पर यह भयानक जवाब। उस उत्तर में बहुत सारी प्रासंगिक जानकारी है, यह पोस्ट सिर्फ इसका सारांश है।


26
2018-06-15 11:26





मुख्य उत्तर थोड़ा उपयोग करके सरलीकृत किया जा सकता है awk:

एक बिग एंडियन प्रणाली पर (सोलारिस, एसपीएआरसी)

$ echo -n I | od -to2 | awk 'FNR==1{ print substr($2,6,1)}'
0

लिटिल एंडियन सिस्टम (लिनक्स, इंटेल) पर

$ echo -n I | od -to2 | awk 'FNR==1{ print substr($2,6,1)}'
1

नए लिनक्स कर्नेल

उपयोग-लिनक्स पैकेज के संस्करण 2.19 के रूप में आदेश कमांड lscpu Endianness से संबंधित एक क्षेत्र सहित शुरू किया। तो अब आप इसे खोजने के लिए बस इस कमांड का उपयोग कर सकते हैं:

$ lscpu | grep -i byte
Byte Order:            Little Endian

उबंटू 12.10 और सेंटोस 6 पर इसकी पुष्टि हुई है। इसलिए मैं यह मानने के लिए तैयार हूं कि अधिकतर 3.0+ लिनक्स कर्नेल अब यह पेशकश कर रहे हैं।

डेबियन / उबंटू सिस्टम पर आप इस कमांड का भी उपयोग कर सकते हैं, यह सुनिश्चित नहीं है कि यह कब उपलब्ध हो गया है:

$ dpkg-architecture | grep -i end
DEB_BUILD_ARCH_ENDIAN=little
DEB_HOST_ARCH_ENDIAN=little

संदर्भ


10
2017-08-30 23:41





यह पायथन लिपि आपके लिए काम करनी चाहिए:

#!/usr/bin/env python
from struct import pack
if pack('@h', 1) == pack('<h', 1):
    print "Little Endian"
else:
    print "Big Endian"

9
2017-07-23 17:28



एक लाइन: python -c "from struct import pack;import sys;sys.exit(int(pack('@h',1)==pack('<h',1)))"। एक्जिट कोड बड़े एंडियन के लिए 0 और थोड़ा एंडियन के लिए 1 है। - Cristian Ciupitu
हा! काफी साफ़! धन्यवाद दोस्तों! - Viet


python -c "import sys; print(sys.byteorder)"

यह प्रणाली के अंतहीनता को मुद्रित करेगा।


6
2018-05-28 07:17





मुझे ज्योथन में ऐसा करने का एक तरीका मिला। चूंकि ज्योथन (जेवीएम पर पायथन) एक वीएम पर चलता है, इसलिए हार्डवेयर के बावजूद यह हमेशा बड़े एंडियन की रिपोर्ट करता है।

यह समाधान लिनक्स, सोलारिस, एईक्स, और एचपीयूएक्स के लिए काम करता है। विंडोज पर परीक्षण नहीं किया है:

    from java.lang import System
    for property, value in dict(System.getProperties()).items():
        if property.endswith('cpu.endian'):
            return value

3
2017-11-30 22:40





आप अपने सिस्टम की अंतहीनता निर्धारित करने के लिए ईएलएफ फ़ाइल प्रारूप का लाभ उठा सकते हैं। उदाहरण के लिए, हेक्स में मनमानी ईएलएफ फ़ाइल के पहले छः बाइट प्रिंट करें:

xxd -c 1 -l 6 /bin/ls

0000000: 7f . 0000001: 45 E 0000002: 4c L 0000003: 46 F 0000004: 02 . 0000005: 01 .

यदि अंतिम पंक्ति (छिद्रित बाइट) 01 है, के अनुसार ईएलएफ प्रारूप, 01 थोड़ा एंडियन है और 02 बड़ा एंडियन है।


3
2018-01-15 18:23



ये है ठीक ठीक मुझे क्या चाहिए धन्यवाद! - Vasily G
मुझे लगता है कि आप एक मनमानी ईएलएफ का मतलब है ... चूंकि शैल स्क्रिप्ट्स, पर्ल, पायथन इत्यादि सहित अन्य निष्पादन योग्य प्रकार हैं। यह नहीं कह रहा कि आप गलत हैं अन्यथा - यह कहकर कि यह याद रखने योग्य है कि अन्य निष्पादन योग्य प्रकार हैं (और ब्याज के लिए कोड टेक्स्ट सेगमेंट में है इसलिए पुरानी टेक्स्ट फ़ाइल व्यस्त त्रुटि)। - Pryftan
@Pryftan इसे इंगित करने के लिए धन्यवाद। इसे ठीक किया! - Tong Zhou
@ टोंगज़ौ आपका स्वागत है; सहायता करके हमें खुशी होगी! - Pryftan


ईएलएफ प्रारूप के आधार पर एक सिंगल लाइन कमांड:
hexdump -s 5 -n 1 /bin/sh


0
2018-04-01 11:36



संपादित करें: -एन 1, क्षमा करें;) - fae
यह एक जैसा ही तरीका है पिछला जवाब, जो आपके से अधिक विवरण भी प्रदान करता है। - kasperd


थोड़ा अलग आवश्यकता: मुझे यह निर्धारित करने के लिए प्रोग्राम को कॉन्फ़िगर करने के लिए एक प्रोग्राम में इस तरह की एक परीक्षण की आवश्यकता है संकलित लक्ष्य मशीन थोड़ा या छोटा एंडियन है, कोड निष्पादित किए बिना। लिपि जमा करनी होगी #define HAVE_LITTLE_ENDIAN 1 में config.h हेडर, या अन्यथा #define HAVE_LITTLE_ENDIAN 0

संकलन लक्ष्य मशीन बिल्ड मशीन से भिन्न हो सकती है, क्योंकि हम क्रॉस-कंपाइलिंग हो सकते हैं, जो यह भी बताता है कि परीक्षण किसी भी संकलित कोड को चलाने का प्रयास क्यों नहीं करना चाहिए। इस सवाल से बाहर है कि एक सी के साथ थोड़ा सी प्रोग्राम है printf बयान जो जवाब को थूकता है।

एक संभावित समाधान यह है। हम एक फाइल जेनरेट करते हैं conftest.c जिसमें यह शामिल है:

#define USPELL(C0, C1, C2, C3) \                                             
  ((unsigned) C0 << 24 | \                                              
   (unsigned) C1 << 16 | \                                              
   (unsigned) C2 << 8 | (unsigned) C3)                                       

unsigned x[6] = {                                                       
  0,                                                                         
  USPELL('L', 'I', 'S', 'P'),                                                
  USPELL('U', 'N', 'I', 'X'),                                                
  USPELL('C', 'O', 'R', 'E'),                                                
  USPELL('D', 'W', 'I', 'M'),                                                
  0                                                                          
};

अब, हम इसे संकलित करते हैं conftest.o का उपयोग करते हुए:

$ /path/to/cross-compiling/cc conftest.c -c

फिर हम दौड़ते हैं:

$ strings conftest.o
PSILXINUEROCMIWD

अगर स्ट्रिंग PSILXINUEROCMIWD होता है, लक्ष्य थोड़ा अंत है। अगर स्ट्रिंग LISPUNIXCOREDWIM होता है, यह बड़ा एंडियन है। यदि न तो स्ट्रिंग होती है या, और भी आश्चर्यजनक रूप से, दोनों करते हैं, तो परीक्षण विफल हो गया है।

यह दृष्टिकोण काम करता है क्योंकि प्रोग्राम में गणना की गई "चार सीसी" स्थिरांक में मशीन-स्वतंत्र मान होते हैं, जो अंतहीनता के बावजूद समान पूर्णांक को दर्शाते हैं। ऑब्जेक्ट फ़ाइल में उनका संग्रहण प्रतिनिधित्व लक्ष्य प्रणाली की अंतहीनता का पालन करता है, और यह चरित्र-आधारित दृश्य के माध्यम से दिखाई देता है strings

दो शून्य गार्ड शब्द सुनिश्चित करते हैं कि स्ट्रिंग अलग है। यह सख्ती से जरूरी नहीं है, लेकिन यह सुनिश्चित करता है कि जिस स्ट्रिंग को हम ढूंढ रहे हैं वह किसी अन्य स्ट्रिंग में एम्बेडेड नहीं है, जिसका अर्थ है strings इसे अपने आप से एक लाइन पर आउटपुट करेगा।

अनुलेख USPELL मैक्रो तर्क सम्मिलन को संश्लेषित नहीं करता है क्योंकि यह इस विशिष्ट उद्देश्य के लिए तैयार किया गया है, फिर से उपयोग के लिए नहीं।


0
2018-05-26 00:37



यह नहीं कि सभी परियोजनाओं के लिए यह जरूरी है लेकिन क्या ऑटोकॉन्फ़ / ऑटोमेक में यह चेक नहीं है? मेरी परियोजनाएं हमेशा छोटी होती हैं जहां मैं अपनी खुद की मेकफ़ाइल (हालांकि हमेशा बुनियादी नहीं) बना सकता हूं, इसलिए जब आवश्यक हो तो मुझे कुछ संशोधनों के अलावा अन्य टूल नहीं मिलते हैं और सामान्य इंटरफ़ेस .. लेकिन मुझे आश्चर्य है कि उन्हें पता लगाना है या नहीं। शायद आपको इसकी आवश्यकता नहीं है, भले ही ऐसा होता है, सिर्फ सोचा कि मैं संभावना को फेंक दूंगा। - Pryftan