NOP (รหัส)

Q: อาดา

ใน ภาษา Ada คำสั่ง นี้ null ทำหน้าที่เป็น NOP [ 35 ] เนื่องจากไวยากรณ์ห้ามไม่ให้คำสั่งควบคุมหรือฟังก์ชันว่างเปล่า null คำสั่งนี้จึงต้องใช้ระบุว่าไม่จำเป็นต้องดำเนินการใดๆ (ดังนั้น หากโปรแกรมเมอร์ลืมเขียนลำดับของคำสั่ง โปรแกรมจะไม่สามารถคอมไพล์ได้)

ในวิทยาการคอมพิวเตอร์ NOP ( no-opหรือNOOPออกเสียงว่า "no op" ย่อมาจากno operation ) คือ คำสั่ง ในภาษาเครื่องและตัวย่อ ใน ภาษาแอสเซมบลีคำ สั่ง ในภาษาโปรแกรมหรือ คำสั่ง โปรโตคอลคอมพิวเตอร์ที่ไม่ทำอะไรเลย

คำสั่งภาษาเครื่อง

ชุดคำสั่งคอมพิวเตอร์บางชุดมีคำสั่งที่มีจุดประสงค์เพื่อไม่ให้เปลี่ยนแปลงสถานะของรีจิสเตอร์แฟล็กสถานะหรือหน่วยความจำ ใดๆ ที่โปรแกรมเมอร์สามารถเข้าถึงได้ คำสั่ง นี้มักใช้จำนวนรอบสัญญาณนาฬิกา ที่กำหนดไว้ในการประมวลผล ในชุดคำสั่งอื่นๆ ไม่มีคำสั่ง NOP ที่ระบุไว้อย่างชัดเจน แต่ตัวย่อ NOP ในภาษาแอสเซ ม บลีแทนคำสั่งที่ทำหน้าที่เหมือน NOP เช่น ในชุดคำสั่งSPARCsethi 0, %g0

คำสั่ง NOP จะต้องไม่เข้าถึงหน่วยความจำ เนื่องจากอาจทำให้เกิดข้อผิดพลาดเกี่ยวกับหน่วยความจำหรือข้อผิดพลาดเกี่ยวกับเพจได้

โดยทั่วไปแล้ว NOP มักใช้เพื่อวัตถุประสงค์ด้านเวลา บังคับการจัดเรียงหน่วยความจำป้องกันอันตรายใช้ช่องหน่วงเวลาการแตกสาขาทำให้คำสั่งที่มีอยู่ เช่น การกระโดด เป็นโมฆะ เป็นเป้าหมายของคำสั่ง executeหรือเป็นตัวยึดตำแหน่งที่จะถูกแทนที่ด้วยคำสั่งที่ใช้งานอยู่ในภายหลังในการพัฒนาโปรแกรม (หรือเพื่อแทนที่คำสั่งที่ถูกลบออกเมื่อการจัดระเบียบใหม่จะเป็นปัญหาหรือใช้เวลานาน) ในบางกรณี NOP อาจมีผลข้างเคียงเล็กน้อย ตัวอย่างเช่น ใน โปรเซสเซอร์ตระกูล Motorola 68000รหัสคำสั่ง NOP ทำให้เกิดการซิงโครไนซ์ของไปป์ไลน์^{[ 1 ]}

ด้านล่างนี้คือคำสั่ง NOP สำหรับสถาปัตยกรรม CPU บางประเภท:

สถาปัตยกรรมซีพียู	ตัว ช่วยจำคำแนะนำ	ไบต์	รหัสปฏิบัติการ	หมายเหตุ
ตระกูล ซีพียู Intel x86	`NOP`	1	0x90 ^{[ 2 ]}	0x90 คือการเข้ารหัสหนึ่งไบต์สำหรับ`XCHG AX,AX`ในโค้ด 16 บิตและ`XCHG EAX,EAX`ในโค้ด 32 บิต ในโหมดยาว`XCHG RAX,RAX`ต้องใช้สองไบต์ เนื่องจากจะเริ่มต้นด้วย`REX.W`คำนำหน้า ทำให้การเข้ารหัสเป็น 0x48 0x90 อย่างไรก็ตาม 0x90 จะถูกตีความว่าเป็น`NOP`ในโหมดยาว โดยไม่คำนึงว่าจะนำหน้าด้วย 0x48 หรือไม่^{[ 2 ]}
	มัลติไบต์`NOP`	2–9 สำหรับ โปรเซสเซอร์ Pentium Proและ Intel รุ่นที่ใหม่กว่า และโปรเซสเซอร์ AMD AMD64 ทุกรุ่น	0x66 0x90 0x0F 0x1F 0x00 0x0F 0x1F 0x40 0x00 0x0F 0x1F 0x44 0x00 0x00 0x66 0x0F 0x1F 0x44 0x00 0x00 0x0F 0x1F 0x80 0x00 0x00 0x00 0x00 0x0F 0x1F 0x84 0x00 0x00 0x00 0x00 0x00 0x66 0x0F 0x1F 0x84 0x00 0x00 0x00 0x00 0x00 ^{[ 2 ]}	0x66 คือคำนำหน้าสำหรับกำหนดค่าขนาดตัวดำเนินการใหม่ 0x0F 0x1F เป็นโอเปรนด์ NOP สองไบต์ที่รับ ตัวถูกดำเนินการ ModR/Mซึ่งไม่มีการเข้าถึงหน่วยความจำและไม่มีการเขียนค่าลงในรีจิสเตอร์ ตัวถูกดำเนินการ ModR/M และตัวถูกดำเนินการที่เพิ่มเข้ามามีดังนี้: 0x00 คือ`[EAX]` 0x40 0x00 คือ`[EAX + 00H]` 0x44 0x00 0x00 คือ`[EAX + EAX1 + 00H]` 0x80 0x00 0x00 0x00 0x00 คือ`[EAX + 00000000H]` 0x84 0x00 0x00 0x00 0x00 0x00 คือ`[EAX + EAX1 + 00000000H]`^{[ 2 ]}
	`FNOP`	2	0xD9 0xD0	ตัวประมวลผลร่วมจุดลอยตัว x87 ไม่มีการดำเนินการ
อินเทล 8008	`LAA`	1	0xC0	โหลด A จาก A
ตระกูล Intel 8048 / MCS-48	`NOP`	1	0x00
ตระกูล Intel 8051 / MCS-51	`NOP`	1	0x00
อินเทล 8080 , 8085 , ซิล็อก Z80	`NOP`	1	0x00
อินเทล ไอ860	`NOP`	4	0xA0000000	การดำเนินการหลักไม่มีอยู่จริง Opcode สำหรับ`shl r0,r0,r0`คำสั่งในการเลื่อนรีจิสเตอร์ที่เป็นศูนย์ทั้งหมดไปทางซ้ายด้วยตัวเอง^{[ 3 ]}
อินเทล ไอ860	`FNOP`	4	0xB0000000	การดำเนินการจุดลอยตัวไม่มีผล Opcode สำหรับ`shrd r0,r0,r0`คำสั่ง shift-right-double ที่รับรีจิสเตอร์ที่เป็นศูนย์ทั้งหมดเป็นอินพุตและเอาต์พุต^{[ 3 ]}
อินเทล ไอ960	`MOV g0,g0`	4	0x5C801610	ย้ายรีจิสเตอร์ส่วนกลาง g0 ไปที่ตัวมันเอง แนะนำให้ใช้โอเปอเรเตอร์สำหรับกรณีที่ไม่ต้องการโอเปอเรเตอร์ใดๆ^{[ 4 ]}
อินเทล IA-64 ( อิทาเนียม )	`(qp) NOP.b imm21`	41 บิต	0x04000000000	บน IA-64 `NOP`คำสั่งมีห้ารูปแบบ แต่ละรูปแบบสามารถดำเนินการได้เฉพาะบนหน่วยประมวลผลประเภทใดประเภทหนึ่งเท่านั้น^{[ 5 ]} ทั้งห้า`NOP`รูปแบบประกอบด้วยฟิลด์ qp 6 บิต (บิตที่ 5:0) และฟิลด์ค่าคงที่ 21 บิต (บิตที่ 36 + บิตที่ 25:6) ฟิลด์เหล่านี้สามารถตั้งค่าเป็นค่าใดก็ได้โดยไม่มีผลต่อการทำงานของคำสั่ง (การเข้ารหัสที่แสดงไว้ในที่นี้ได้มาจากการตั้งค่าฟิลด์เหล่านี้เป็น 0 ทั้งหมด ซึ่งเป็นเรื่องปกติแต่ไม่จำเป็น) รูป`NOP.x`แบบของคำสั่งนี้ยังใช้ช่องคำสั่งขนาด 41 บิตช่องที่สองด้วย โดยเนื้อหาในช่องนี้ถือว่าเป็นการให้ค่าคงที่เพิ่มเติมอีก 41 บิต ทำให้ขนาดของค่าคงที่ทั้งหมดเป็น 62 บิต
	`(qp) NOP.f imm21`	41 บิต	0x00008000000
	`(qp) NOP.i imm21`
	`(qp) NOP.m imm21`
	`(qp) NOP.x imm62`	41+41 บิต	0x00008000000 imm41

ARM 32 บิต (A32)	`NOP`	4	0x*320F000	สถาปัตยกรรม ARM A32 NOP ("NOP ที่แท้จริง" โดยไม่มีการพึ่งพารีจิสเตอร์) เปิดตัวพร้อมกับ ARMv6K ( ARM 11 76 ซึ่งวางจำหน่ายในปี 2546) และมีอยู่ในโปรเซสเซอร์ ARM A32 รุ่นต่อมาทั้งหมด (เครื่องหมาย * แสดงถึงฟิลด์ 4 บิตที่สามารถรับค่าใดก็ได้ที่ไม่ใช่ 0xF) ^{[ 6 ]}
	`MOV r0,r0`/`NOP`	4	0xE1A00000	แนะนำการเข้ารหัส A32 ที่ไม่มีการดำเนินการสำหรับโปรเซสเซอร์ ARM 32 บิตรุ่นเก่าที่มาก่อน ARMv6K โดยปกติแล้วแอสเซมเบลอร์สำหรับ A32 จะส่งออกโอเปอเรเตอร์โค้ดนี้เมื่อได้รับตัวย่อ "NOP" เว้นแต่จะได้รับคำสั่งให้กำหนดเป้าหมายเป็น ARMv6K หรือสถาปัตยกรรม ARM เวอร์ชันที่ใหม่กว่า^{[ 7 ]}^{[ 8 ]}
	`ANDEQ r0,r0,r0`	4	0x00000000	ดำเนินการ Bitwise-AND r0 กับตัวเองหากเท่ากัน การเข้ารหัสแบบไม่มีการดำเนินการที่ใช้กันทั่วไปเนื่องจากความเรียบง่ายของการเข้ารหัส^{[ 9 ]}
	`MOVNV r0,r0`	4	0xF1A00000	ย้าย r0 ไปที่ตัวเองไม่เคย การเข้ารหัสแบบไม่มีการดำเนินการที่ล้าสมัยซึ่งเคยแนะนำสำหรับโปรเซสเซอร์ ARM2/ARM3 ในคอมพิวเตอร์Acorn Archimedes รุ่นเก่า ^{[ 9 ]}^{[ 10 ]}ใช้รหัสเงื่อนไข NV ("ไม่เคย") ซึ่งถูกยกเลิกการใช้งานตั้งแต่ปี 1993 ^{[ 11 ]}และการสนับสนุนถูกลบออกอย่างสมบูรณ์ใน ARMv5 ^{[ 12 ]}
นิ้วโป้ง	`MOV r8,r8`/`NOP`	2	0x46C0	แนะนำการเข้ารหัสแบบไม่มีการดำเนินการสำหรับโปรเซสเซอร์ Thumb 32 บิตรุ่นเก่าที่มาก่อน ARMv6T2 โดยปกติแล้วแอสเซมเบลอร์สำหรับ T32 จะส่งออกโอเปอเรเตอร์โค้ดนี้เมื่อได้รับตัวย่อ "NOP" เว้นแต่จะได้รับคำสั่งให้กำหนดเป้าหมายเป็น ARMv6T2 หรือสถาปัตยกรรม ARM Thumb เวอร์ชันที่ใหม่กว่า^{[ 7 ]}^{[ 8 ]}
นิ้วโป้ง-2 (T32)	`NOP`	2	0xBF00	สถาปัตยกรรม ARM T32 (Thumb-2) NOPs ("true" nops, ไม่มีการพึ่งพารีจิสเตอร์) เปิดตัวพร้อมกับ ARMv6T2 ( ARM 11 56, เปิดตัวในปี 2546) และมีอยู่ในโปรเซสเซอร์ ARM T32 รุ่นต่อมาทั้งหมด^{[ 6 ]}
นิ้วโป้ง-2 (T32)	`NOP.W`	4	0xF3AF8000
ARM 64 บิต (A64)	`NOP`	4	0xD503201F	สถาปัตยกรรม NOP

เดค อัลฟ่า	`NOP`	4	0x47FF041F	จำนวนเต็ม NOP รหัสปฏิบัติการสำหรับ`BIS r31,r31,r31`คำสั่งที่ทำการ OR บิตกับรีจิสเตอร์ที่เป็นศูนย์เสมอ^{[ 13 ]}
	`FNOP`	4	0x5FFF041F	NOP จุดลอยตัว Opcode สำหรับ`CPYS f31,f31,f31`คำสั่งที่ทำการคัดลอกเครื่องหมายโดยใช้รีจิสเตอร์ที่เป็นศูนย์เสมอเป็นแหล่งที่มาของทั้งเครื่องหมายและเลขชี้กำลัง/แมนทิสซา และเก็บผลลัพธ์ไว้ในรีจิสเตอร์ที่เป็นศูนย์เสมอ^{[ 13 ]}
	`UNOP`	4	0x2FFE0000	NOP สากล รหัสปฏิบัติการสำหรับ`LDQ_U r31,0($sp)`. รหัสปฏิบัติการ LDQ_U (โหลดที่ไม่ตรงแนว) ในเวอร์ชัน 21164 และเวอร์ชันต่อมา จะถูกจัดการเป็นพิเศษเพื่อให้เมื่อใช้กับรีจิสเตอร์ที่มีค่าเป็น 0 เสมอเป็นรีจิสเตอร์ปลายทาง จะไม่มีการเข้าถึงหน่วยความจำเกิดขึ้น^{[ 13 ]}^{[ 14 ]}รีจิสเตอร์ที่อยู่และการเลื่อนตำแหน่งอาจมีค่าใดก็ได้ แต่โดยทั่วไปจะกำหนดเป็น`0($sp)`ซึ่งก็คือตัวชี้สแต็ก + ศูนย์^{[ 15 ]}
AMD 29k	`NOP`	4	0x70400101	รหัสปฏิบัติการสำหรับ`aseq 0x40,gr1,gr1`คำสั่งที่ยืนยันว่ารีจิสเตอร์สแต็กเท่ากับตัวมันเอง^{[ 16 ]}
เอวีอาร์	`NOP`	2	0x0000	หนึ่งรอบนาฬิกา
COP400	`NOP`	1	0x44
COP8	`NOP`	1	0xB8
เอชพี 3000	`NOP`	2	0x0000	คำสั่งการทำงานของสแต็ก HP 3000 มีบิตสำคัญที่สุดสี่บิตเป็น 0 ตามด้วยรหัสการทำงานของสแต็ก 6 บิตสองรหัส โดยใช้สแต็ก NOP (0) เพื่อเติมเมื่อจำเป็น 0x0000 จะเป็น NOP, NOP ^{[ 17 ]}
ไฮเปอร์สโตน อี1	`NOP`	2	0x0300	รหัสปฏิบัติการสำหรับ`CHK L0,L0`คำสั่งตรวจสอบช่วงซึ่งจะสร้างข้อยกเว้นหากรีจิสเตอร์ L0 มากกว่าตัวมันเอง^{[ 18 ]}
IBM System/360 , IBM System/370 , IBM System/390 , z/Architecture , UNIVAC Series 90	`NOP`	4	0x47000000 หรือ 0x470nnnnn หรือ 0x47n0nnnn โดยที่ "n" คือค่า 4 บิตใดๆ	คำสั่ง NOP ("No-Op") และ NOPR ("No-Op Register") เป็นส่วนย่อยของคำสั่ง "Branch on Condition" หรือ "Branch on Condition Register" ตามลำดับ โดยทั้งสองเวอร์ชันมีสองตัวเลือกสำหรับการสร้าง NO-OP ในกรณีของคำสั่ง NOP และ NOPR ทั้งสองคำสั่งนั้น เลข 0 ตัวแรกในไบต์ที่สองคือค่า "มาสก์" ซึ่งเป็นเงื่อนไขที่จะทดสอบ เช่น เท่ากัน ไม่เท่ากัน สูง ต่ำ เป็นต้น หากมาสก์เป็น 0 จะไม่มีการกระโดดไปยังอีกทางหนึ่ง ในกรณีของคำสั่ง NOPR ค่าที่สองในไบต์ที่สองคือรีจิสเตอร์ที่จะใช้ในการกระโดด หากเลือกใช้รีจิสเตอร์ 0 จะไม่มีการกระโดดเกิดขึ้นไม่ว่าค่ามาสก์จะเป็นเท่าใดก็ตาม ดังนั้น หากค่าใดค่าหนึ่งในสองค่าในไบต์ที่สองเป็น 0 การกระโดดจะไม่เกิดขึ้น หาก 0 ตัวแรกในไบต์ที่สองเป็น 0 ค่าของค่าที่สองในไบต์ที่สองจะไม่มีความสำคัญในโปรเซสเซอร์ส่วนใหญ่ อย่างไรก็ตาม ในIBM System/360 Model 91หากค่าดังกล่าวอ้างอิงถึงรีจิสเตอร์ 15 คำสั่งจะรอให้คำสั่งที่ถอดรหัสก่อนหน้านี้ทั้งหมดเสร็จสมบูรณ์ก่อนจึงจะดำเนินการต่อ^{[ 19 ]} ในกรณีของคำสั่ง NOP ค่าที่สองในไบต์ที่สองคือรีจิสเตอร์ "ฐาน" ของรีจิสเตอร์ฐานรวม รีจิสเตอร์ตำแหน่ง และแอดเดรสออฟเซ็ต หากรีจิสเตอร์ฐานเป็น 0 ด้วย การกระโดดจะไม่เกิดขึ้นโดยไม่คำนึงถึงค่าของรีจิสเตอร์ตำแหน่งหรือแอดเดรสตำแหน่ง
	`NOPR`	2	0x0700 หรือ 0x070n หรือ 0x07n0 โดยที่ "n" คือค่า 4 บิตใดๆ
ลุงอาร์ช	`NOP`	4	0x03400000	Opcode สำหรับ`andi r0,r0,0`คำสั่งที่ทำการ AND แบบบิตกับรีจิสเตอร์ที่เป็นศูนย์เสมอ^{[ 20 ]}
ไมโครเบลซ	`NOP`	4	0x80000000	Opcode สำหรับ`or r0,r0,r0`คำสั่งที่ทำการ OR บิตกับรีจิสเตอร์ที่เป็นศูนย์เสมอ^{[ 21 ]}
เอ็มไอพีเอส	`NOP`	4	0x00000000	ย่อมาจาก`sll r0,r0,0`ซึ่งหมายถึง: เลื่อนบิตศูนย์ในรีจิสเตอร์ 0 ไปทางซ้ายอย่างมีตรรกะ และเก็บผลลัพธ์ไว้ในรีจิสเตอร์ 0 การเขียนลงในรีจิสเตอร์ 0 จะถูกละเลย เนื่องจากรีจิสเตอร์ 0 จะมีค่าเป็น 0 เสมอ
เอ็มไอพีเอสเอ็กซ์	`NOP`	4	0x60000019	(รหัสคำสั่งเพิ่มเติมสำหรับ`add r0,r0,r0`)
ผสม	`NOP`	1 คำ	± * * * * 0	ไบต์ * เป็นค่าที่กำหนดขึ้นเองได้ และสามารถเป็นอะไรก็ได้ตั้งแต่ 0 ถึงไบต์สูงสุด (ซึ่งต้องอยู่ในช่วง 63-99) MIX ใช้การแสดงผลแบบ sign-magnitude
เอ็มมิกซ์	`SWYM`	4	0xFD******	SWYM ย่อมาจาก "Sympathize with your machinery" (เห็นอกเห็นใจเครื่องจักรของคุณ) ตัวเลข * สามารถเลือกได้ตามต้องการ
MOS Technology 65xx (เช่น6502 ), WDC 65C816	`NOP`	1	0xEA	คำสั่ง NOP ใช้เวลาสองรอบสัญญาณนาฬิการหัส คำสั่งที่ไม่กำหนดไว้ใน เวอร์ชัน NMOSของตระกูล 65xx ถูกแปลงเป็นคำสั่ง NOP ที่มีความยาวคำสั่งและเวลาต่อรอบสัญญาณนาฬิกาที่แตกต่างกันใน65C02
โมโตโรลา 6800	`NOP`	1	0x01
ตระกูล Motorola 68000	`NOP`	2	0x4E71	สิ่งนี้จะซิงโครไนซ์ไปป์ไลน์และป้องกันการทับซ้อนของคำสั่ง^{[ 1 ]}^{: 3-21}^{[ 1 ]}^{: 4-147}
ตระกูล Motorola 68000	`TRAPF`, `TRAPF.W #data`,`TRAPF.L #data`	2, 4, 6	0x51FC, 0x51FA 0xnnnn, 0x51FB 0xnnnn 0xnnnn	ดักจับข้อผิดพลาดหากเป็นเท็จ รหัสปฏิบัติการที่แนะนำสำหรับ โปรเซสเซอร์ 68020และ 68k รุ่นหลัง หากต้องการ NOP โดยไม่มีการซิงโครไนซ์ไปป์ไลน์ ('n' อาจมีค่า 4 บิตใดก็ได้) ^{[ 1 ]}^{: 3-21}^{[ 1 ]}^{: 4-189}
โมโตโรลา 6809	`NOP`	1	0x12
ตระกูล Motorola 88000	`BCND lt0,r0,X`, `ADD r0,r0,r0`,`TB1 0,r0,x`	4	0xE980xxxx, 0xF4007000, 0xF000D8xx	แยกสาขาหากรีจิสเตอร์ always-0 น้อยกว่า 0 เพิ่มรีจิสเตอร์ always-0 เข้ากับตัวเองดักจับหากบิต 0 ของรีจิสเตอร์ always-0 เป็น 1 (เรียงลำดับ) ^{[ 22 ]}
เอ็มเอสพี430	`NOP`	2	0x4303	รหัสปฏิบัติการสำหรับ`mov #0,r3`หรือ`mov r3,r3`คำสั่งที่ดำเนินการย้ายจาก "รีจิสเตอร์สร้างค่าคงที่" ไปยังตัวมันเอง^{[ 23 ]}
พีเอ-ริสซี	`NOP`	4	0x08000240	รหัสปฏิบัติการสำหรับ`OR 0,0,0`. ^{[ 24 ]}
พีเอ-ริสซี	`LDI 26,0`	4	0x34000034	NOP ที่เป็นพาลินโดรม – นั่นคือ คำสั่งที่ทำงานเป็น NOP โดยไม่คำนึงถึงว่าลำดับไบต์จะถูกตีความว่าเป็นlittle-endian หรือ big-endianคำสั่งระบบ PA-RISC บางคำสั่งจำเป็นต้องมี NOP ที่เป็นพาลินโดรมเจ็ดตัวตามหลัง^{[ 24 ]}
พีดีพี-6 , พีดีพี-10	`JFCL 0,`(ธรรมดา)`JUMP, SETA, SETAI, CAI, TRN, TLN`	1 คำ	25500******* (เลขฐานแปด)	กระโดดเลยกระโดดเลย ตั้งค่าอะไรไว้เลย ข้ามเลย
พีดีพี-11	`NOP`	2	000240 (เลขฐานแปด)	ล้างรหัสเงื่อนไขทั้งหมด
ไมโครคอนโทรลเลอร์ PIC	`NOP`	12 บิต	0b000000000000	จำนวนบิตในคำสั่ง NOP จะแตกต่างกันไปตามแต่ละรุ่น
พลังงาน , พาวเวอร์พีซี , พาวเวอร์ไอเอ	`NOP`	4	0x60000000	รหัสปฏิบัติการสำหรับ`ori r0,r0,0`. ภายใต้ Power ISA การเข้ารหัสคำสั่งที่ดูเหมือนจะไม่มีการดำเนินการใดๆ หลายอย่างมีผลข้างเคียงที่สำคัญ ดังนั้น`ori r0,r0,0`ควรหลีกเลี่ยงการเข้ารหัสที่ไม่มีการดำเนินการใดๆ อื่นๆ อย่างระมัดระวัง เว้นแต่ผลข้างเคียงเหล่านี้มีจุดประสงค์โดยเฉพาะ ตัวอย่างเช่น: ^{[ 25 ]} `ori r31,r31,0`เป็นคำสั่งการจัดลำดับแบบอนุกรม `or rX,rX,rX`โดยที่ X=1,2,3,5,6,7 หรือ 31 จะกำหนดลำดับความสำคัญของเธรดตามค่า X `or r26,r26,r26`เป็นคำแนะนำในการเขียนข้อมูลกลับไปยังหน่วยความจำ `xori r0,r0,0`เป็นคำสั่ง no-op ที่ไม่ได้ปรับแต่งประสิทธิภาพอย่างชัดเจน สำหรับใช้ในลูปจับเวลา `and rX,rX,rX`โดยที่ X=0,1 คือการตรวจสอบประสิทธิภาพที่ไม่มีการดำเนินการใดๆ `or rX,rX,rX`เมื่อ X=28,29,30,31 จะทำให้การส่งคำสั่งหยุดชะงักเป็นจำนวนรอบ CPU ที่กำหนดไว้บนโปรเซสเซอร์ที่ใช้ IBM PPE ^{[ 26 ]} `ori rX,rX,0`โดยที่ X=1,2 คือ "NOP สิ้นสุดกลุ่ม" ในซีพียู POWER บางตัว ^{[ 27 ]}^{[ 28 ]}
RISC-V	`NOP`	4	0x00000013	`ADDI x0, x0, 0`
RISC-V	`C.NOP`	2	0x0001	`C.ADDI x0, 0`ใช้ได้เฉพาะกับซีพียู RISC-V ที่รองรับส่วนขยาย "C" (คำสั่งบีบอัด) เท่านั้น^{[ 29 ]}
ซิกเนติกส์ 8X300	`MOV AUX, AUX`	2 (16 บิต)	0x0000	ย้าย AUX ไปที่ AUX โดยไม่ต้องหมุน
สปาร์ค	`NOP`	4	0x01000000	แทนค่าศูนย์ในรีจิสเตอร์`sethi 0, %g0`ที่ต่อสายตรงเป็นศูนย์^[³⁰^]`%g0`
ซันพลัส เอส+คอร์	`NOP`	4	0x80008000	NOP ทางสถาปัตยกรรม^{[ 31 ]}
ซันพลัส เอส+คอร์	`NOP!`	2	0x0000	NOP ทางสถาปัตยกรรม^{[ 31 ]}
ซูเปอร์เอช	`NOP`	2	0x0009	^{[ 32 ]}
ซูเปอร์เอช	`NOP`	4	0x6FF0FFF0	NOP 32 บิต มีเฉพาะใน SH-5 เท่านั้น^{[ 33 ]}
เทนซิลิก้าเอ็กซ์เทนซ่า	`NOP`,`_NOP`	3	0x0020F0	แอสเซมเบลอร์อาจแปลง "NOP" เป็น "NOP.N" – สามารถใช้ตัวย่อ "_NOP" (โดยมีขีดล่างนำหน้า) เพื่อป้องกันการแปลงดังกล่าวได้^{[ 34 ]}
เทนซิลิก้าเอ็กซ์เทนซ่า	`NOP.N`	2	0xF03D
แวกซ์	`NOP`	1	0x01	ความล่าช้าขึ้นอยู่กับประเภทของโปรเซสเซอร์
WD16	`NOP`	2	0x0000

จากมุมมองการออกแบบฮาร์ดแวร์ พื้นที่ที่ไม่ได้แมปบนบัสส่วนใหญ่มักถูกออกแบบให้ส่งค่าศูนย์กลับมา เนื่องจาก พฤติกรรม การเลื่อน NOPมักเป็นที่ต้องการ จึงทำให้มีแนวโน้มที่จะเขียนโค้ดโดยใช้รหัสคำสั่งที่เป็นศูนย์ทั้งหมด

รหัส

ฟังก์ชันหรือลำดับของคำสั่งในภาษาโปรแกรมจะเป็นคำสั่ง NOP หรือคำสั่งว่าง หากไม่มีผลใดๆในบางบริบท ไวยากรณ์ ของบางภาษาอาจกำหนดให้ต้องใช้คำสั่งว่าง

อาดา

ในภาษา Ada คำสั่ง นี้nullทำหน้าที่เป็น NOP ^{[ 35 ]}เนื่องจากไวยากรณ์ห้ามไม่ให้คำสั่งควบคุมหรือฟังก์ชันว่างเปล่าnullคำสั่งนี้จึงต้องใช้ระบุว่าไม่จำเป็นต้องดำเนินการใดๆ (ดังนั้น หากโปรแกรมเมอร์ลืมเขียนลำดับของคำสั่ง โปรแกรมจะไม่สามารถคอมไพล์ได้)

ซี และอนุพันธ์

คำสั่ง NOP ที่ง่ายที่สุดในภาษา C คือคำสั่ง nullซึ่งก็คือเครื่องหมายเซมิโคลอนในบริบทที่ต้องการคำสั่ง

คอมไพเลอร์ภาษา C ส่วนใหญ่จะไม่สร้างโค้ดสำหรับคำสั่งที่มีค่าเป็น null ซึ่งมีเหตุผลทั้งในด้านประวัติศาสตร์และประสิทธิภาพ

บล็อกว่าง (คำสั่งประกอบ) ก็เป็น NOP เช่นกัน และอาจอ่านง่ายกว่า แต่คอมไพเลอร์ก็จะไม่สร้างโค้ดสำหรับบล็อกนั้นอยู่ดี

{}

ในบางกรณี เช่น ในส่วนของฟังก์ชัน จำเป็นต้องใช้บล็อก แต่บล็อกนั้นอาจว่างเปล่าได้ ในภาษาซี คำสั่งไม่สามารถว่างเปล่าได้ คำสั่งแบบง่ายต้องลงท้ายด้วยเครื่องหมาย;เซมิโคลอน (;) ในขณะที่คำสั่งแบบซับซ้อนจะอยู่ภายใน{}วงเล็บปีกกา (;) ซึ่งไม่จำเป็นต้องมีเครื่องหมายเซมิโคลอนตามหลัง ดังนั้น ในบริบทที่จำเป็นต้องใช้คำสั่งตามหลักไวยากรณ์ จึงสามารถใช้คำสั่งว่างเปล่าดังกล่าวได้

คำสั่ง null นั้นไม่มีประโยชน์ในตัวมันเอง แต่สามารถนำไปใช้ในเชิงไวยากรณ์ได้ในบริบทที่กว้างกว่า เช่น ในบริบทของลูป:

ในขณะที่( getchar () != '\n' ) {}

หรืออีกทางเลือกหนึ่ง

ในขณะที่( getchar () != '\n' ) ;

หรือกล่าวโดยย่อ:

ในขณะที่( getchar () != '\n' );

รูปแบบสุดท้ายอาจทำให้เกิดคำเตือนกับคอมไพเลอร์บางตัวหรือตัวเลือกคอมไพเลอร์บางตัว เนื่องจากเครื่องหมายเซมิโคลอนที่วางไว้หลังวงเล็บที่ท้ายบรรทัดมักบ่งชี้ถึงจุดสิ้นสุดของนิพจน์การเรียกใช้ฟังก์ชัน

โค้ดข้างต้นจะเรียกฟังก์ชันซ้ำไปเรื่อยๆgetchar()จนกว่าจะได้อักขระ\n(ขึ้นบรรทัดใหม่) กลับมา ซึ่งโดยพื้นฐานแล้วเป็นการเลื่อนตำแหน่งการอ่านปัจจุบันของข้อมูลป้อนเข้ามาตรฐานไปยังจุดเริ่มต้นของบรรทัดถัดไปอย่างรวดเร็ว

ฟอร์ทราน

ในภาษาฟอร์ทราน คำสั่ง นี้CONTINUEใช้ในบางบริบท เช่น คำสั่งสุดท้ายในลูป DO แม้ว่าจะสามารถใช้ได้ทุกที่ และไม่มีฟังก์ชันการทำงานใดๆ

โค้ด JavaScript

ภาษาJavaScriptไม่มีคำสั่ง NOP ในตัว แต่สามารถนำไปใช้ได้หลายวิธี:

ใช้;คำสั่งว่าง^{[ 36 ]}หรือคำสั่งบล็อก{}ว่างในลักษณะเดียวกับในตัวอย่างC และอนุพันธ์
ใช้ คำสั่ง ` undefinedor` หรือ ` nullexpression` เป็นคำสั่งที่สมบูรณ์ ( คำสั่งนิพจน์ ) เมื่อวิธีการก่อนหน้านี้ไม่ได้รับอนุญาตตามไวยากรณ์

ทางเลือกอื่น ๆ ในกรณีที่จำเป็นต้องใช้ฟังก์ชัน ได้แก่:

ใช้Function.prototype()ฟังก์ชันในตัวที่รับอาร์กิวเมนต์ใดๆ และส่งคืนค่าundefined; ^{[ 37 ]}
ใช้ฟังก์ชัน NOP ที่มีอยู่ในไลบรารีของบุคคลที่สาม —ดูรายละเอียดด้านล่าง;
กำหนดฟังก์ชัน NOP แบบกำหนดเอง ดังตัวอย่างต่อไปนี้ (โดยใช้ไวยากรณ์ฟังก์ชันลูกศรของ ES6 ):

const noop = () => {};

แองกูลาร์เจเอส

เฟรม เวิร์ก AngularJSมี ฟังก์ชัน angular.noopที่ไม่ทำการดำเนินการใดๆ

jQuery

ไลบรารีjQueryมีฟังก์ชันjQuery.noop()ซึ่งไม่ได้ทำอะไรเลย^{[ 38 ]}

โลแดช

ไลบรารีLodashมีฟังก์ชัน_.noop()ที่ส่งคืนค่า undefined และไม่ทำอะไรเลย^{[ 39 ]}

ปาสคาล

เช่นเดียวกับในภาษาซี เครื่องหมายเซมิโคลอน (;) ที่ใช้เพียงลำพังสามารถใช้เป็นคำสั่งว่างในภาษาปาสคาลได้อันที่จริง เนื่องจากข้อกำหนดของภาษา ในบล็อก BEGIN/END เครื่องหมายเซมิโคลอนเป็นตัวเลือกก่อนคำสั่ง END ดังนั้นการใช้เครื่องหมายเซมิโคลอนตรงนั้นจึงไม่จำเป็น

นอกจากนี้ บล็อกที่ประกอบด้วย <br> BEGIN END;อาจใช้เป็นตัวยึดตำแหน่งเพื่อระบุว่าไม่มีการดำเนินการใดๆ แม้ว่าจะวางไว้ภายในบล็อก BEGIN/END อื่นก็ตาม

ไพธอน

ภาษาโปรแกรม Python มีคำสั่งที่ไม่มีผลใดๆ เมื่อถูกเรียกใช้งาน จึงเรียกว่า NOP (Not Only Operation) โดยหลักแล้วใช้เพื่อตรวจสอบความถูกต้องของไวยากรณ์ เนื่องจากไวยากรณ์ของ Python นั้นไว ต่อการเว้นวรรคตัวอย่างเช่น ไวยากรณ์สำหรับการกำหนดคลาสจำเป็นต้องมีบล็อกที่เว้นวรรคพร้อมตรรกะของคลาส ซึ่งจะต้องแสดงเป็น ` null` เมื่อควรจะเป็นบล็อกว่างเปล่า passpass

การเขียนสคริปต์เชลล์ (bash, zsh เป็นต้น)

คำสั่ง ' :' [โคลอน] เป็นคำสั่งภายในของเชลล์ที่มีผลคล้ายกับ "NOP" (การดำเนินการที่ไม่ทำอะไรเลย) ในทางเทคนิคแล้วมันไม่ใช่ NOP เพราะมันเปลี่ยนพารามิเตอร์พิเศษ $? (สถานะการออกของคำสั่งสุดท้าย) เป็น 0 อาจถือได้ว่าเป็นคำพ้องความหมายของคำสั่งภายในของเชลล์ 'true' และสถานะการออกของมันคือ true (0) ^{[ 40 ]}^{[ 41 ]}^{[ 42 ]}

ภาษามาโคร TeX (ConTeXt, LaTeX เป็นต้น)

ภาษามาโครของระบบการพิมพ์ TeX มีคำสั่ง^[⁴³^] คำสั่ง นี้ไม่ได้ทำอะไรด้วยตัวเอง แต่สามารถใช้เพื่อป้องกันไม่ให้คำสั่งก่อนหน้าวิเคราะห์โทเค็นใดๆ ที่ตามมาได้^[⁴⁴^]\relax

คำสั่งโปรโตคอล NOP

โปรโตคอลคอมพิวเตอร์หลายตัวเช่นtelnetมีคำสั่ง NOOP ที่ไคลเอ็นต์สามารถใช้เพื่อขอการตอบกลับจากเซิร์ฟเวอร์โดยไม่ต้องร้องขอการดำเนินการอื่นใด คำสั่งดังกล่าวสามารถใช้เพื่อตรวจสอบว่าการเชื่อมต่อยังคงใช้งานได้หรือเซิร์ฟเวอร์ตอบสนองหรือไม่ คำสั่ง NOOP เป็นส่วนหนึ่งของโปรโตคอลต่อไปนี้ ( นี่เป็นเพียงส่วนหนึ่ง ):

แตกต่างจากโปรโตคอลอื่นๆ ที่กล่าวมา คำสั่ง IMAP4 NOOP มีจุดประสงค์เฉพาะ คือ ช่วยให้เซิร์ฟเวอร์สามารถส่งการแจ้งเตือนที่ค้างอยู่ไปยังไคลเอ็นต์ได้

ในขณะที่เซิร์ฟเวอร์ telnetหรือFTPส่วนใหญ่จะตอบสนองต่อคำสั่ง NOOP ด้วย "OK" หรือ "+OK" โปรแกรมเมอร์บางคนได้เพิ่มการตอบสนองที่แปลกประหลาดให้กับไคลเอนต์ ตัวอย่างเช่นftpddaemon ของMINIXตอบสนองต่อ NOOP ด้วยข้อความ: ^{[ 45 ]}

ขอให้คุณโชคดีเช่นกัน! (200 NOOP!)

การแตก

NOP มักเกี่ยวข้องกับการถอดรหัสซอฟต์แวร์ที่ตรวจสอบหมายเลขซีเรียล ข้อกำหนดเฉพาะของฮาร์ดแวร์หรือซอฟต์แวร์ การมีหรือไม่มีดอง เกิลฮาร์ดแวร์ ฯลฯ ในรูปแบบของสไลด์ NOPกระบวนการนี้ทำได้โดยการเปลี่ยนแปลงฟังก์ชันและซับรูทีนเพื่อข้ามการตรวจสอบความปลอดภัยและส่งคืนค่าที่คาดหวังแทน เนื่องจากคำสั่งส่วนใหญ่ในรูทีนตรวจสอบความปลอดภัยจะไม่ถูกใช้งาน คำสั่งเหล่านั้นจะถูกแทนที่ด้วย NOP ซึ่งจะลบฟังก์ชันการรักษาความปลอดภัยของซอฟต์แวร์โดยไม่เปลี่ยนแปลงตำแหน่งของทุกอย่างที่ตามมาในไบนารี

ช่องโหว่ด้านความปลอดภัย

โอเปอเรเตอร์โค้ด NOP สามารถใช้สร้างNOP slideซึ่งช่วยให้โค้ดสามารถทำงานได้เมื่อค่าที่แน่นอนของตัวชี้คำสั่งไม่แน่นอน (เช่น เมื่อบัฟเฟอร์โอเวอร์โฟลว์ทำให้ที่อยู่ส่งคืนของฟังก์ชันบนสแต็กถูกเขียนทับ)

ดูเพิ่มเติม

คำอธิบาย (การเขียนโปรแกรมคอมพิวเตอร์) – คำอธิบายประกอบที่โดยทั่วไปแล้วมีไว้สำหรับโปรแกรมเมอร์ ซึ่งคอมไพเลอร์และอินเตอร์พรีเตอร์จะไม่สนใจ
สถาปัตยกรรมคอมพิวเตอร์
ข้อความตัวอย่าง
Halt and Catch Fire – ยังหยุดการทำงานของ CPU ชั่วคราวด้วย
HLT (คำสั่ง x86) – หยุดการทำงานของ CPU ชั่วคราว
ฟังก์ชันเอกลักษณ์ – เทียบเท่ากับ NOP ในการเขียนโปรแกรมเชิงฟังก์ชัน
IEFBR14 – สัจนิรันดร์ของเมนเฟรม
xyzzy (คอมพิวเตอร์) – คำสั่งที่บางครั้งใช้แทน NOP
รายการคำสั่ง X86 #เพิ่มในโปรเซสเซอร์ระดับ P5/P6 – NOPLรายการคำสั่งแบบยาวอย่างเป็นทางการNOP

[ 1 ]

[ 2 ]

[ 3 ]

[ 4 ]

[ 5 ]

[ 6 ]

[ 7 ]

[ 8 ]

[ 9 ]

[ 10 ]

[ 11 ]

[ 12 ]

[ 13 ]

[ 14 ]

[ 15 ]

[ 16 ]

[ 17 ]

[ 18 ]

[ 19 ]

[ 20 ]

[ 21 ]

[ 22 ]

[ 23 ]

[ 24 ]

[ 25 ]

[ 26 ]

[ 27 ]

[ 28 ]

[ 29 ]

[

[ 31 ]

[ 32 ]

[ 33 ]

[ 34 ]

[ 35 ]

[ 36 ]

[ 37 ]

[ 38 ]

[ 39 ]

[ 40 ]

[ 41 ]

[ 42 ]

[

[

[ 45 ]