ทำไมคอมไพเลอร์ GCC จึงไม่ใช้รหัสบางอย่าง

ฉันไม่สามารถเข้าใจว่าทำไม GCC คอมไพเลอร์ตัดส่วนของรหัสของฉันในขณะที่มันรักษารหัสเดียวกันในละแวก?

รหัส C:

#define setb_SYNCO do{(PORTA|= (1<<0));} while(0);

ISR(INT0_vect){
    unsigned char i;

    i = 10;
    while(i>0)i--;   // first pause - omitted

    setb_SYNCO;
    setb_GATE;
    i=30;
    clrb_SYNCO;
    while(i>0)i--;  // second pause - preserved
    clrb_GATE;
}

ส่วนที่สอดคล้องกันของ LSS (ไฟล์แอสเซมเบลอร์ที่สร้างโดยคอมไพเลอร์):

ISR(INT0_vect){
  a4:   1f 92           push    r1
  a6:   0f 92           push    r0
  a8:   0f b6           in  r0, 0x3f    ; 63
  aa:   0f 92           push    r0
  ac:   11 24           eor r1, r1
  ae:   8f 93           push    r24
    unsigned char i;

    i = 10;
    while(i>0)i--;

    setb_SYNCO;
  b0:   d8 9a           sbi 0x1b, 0 ; 27
    setb_GATE;
  b2:   d9 9a           sbi 0x1b, 1 ; 27
    i=30;
    clrb_SYNCO;
  b4:   d8 98           cbi 0x1b, 0 ; 27
  b6:   8e e1           ldi r24, 0x1E   ; 30
  b8:   81 50           subi    r24, 0x01   ; 1
    while(i>0)i--;
  ba:   f1 f7           brne    .-4         ; 0xb8 <__vector_1+0x14>
    clrb_GATE;
  bc:   d9 98           cbi 0x1b, 1 ; 27
}
  be:   8f 91           pop r24
  c0:   0f 90           pop r0
  c2:   0f be           out 0x3f, r0    ; 63
  c4:   0f 90           pop r0
  c6:   1f 90           pop r1
  c8:   18 95           reti

ฉันสามารถสันนิษฐานได้ว่าคอมไพเลอร์คิดว่ารหัสนั้นหลอกตาและตัดมันออก แต่ทำไมมันถึงรักษารหัสเดียวกันในตอนท้ายของรหัส?

มีคำแนะนำในการคอมไพเลอร์เพื่อป้องกันจากการเพิ่มประสิทธิภาพดังกล่าว?

เนื่องจากในความคิดเห็นหนึ่งคุณระบุว่า "ขีด จำกัด ของ CPU แต่ละอันมีค่า" ฉันแนะนำให้ใช้ชุดประกอบแบบอินไลน์เพื่อทำให้ความล่าช้าของคุณวนซ้ำตามที่คุณต้องการ การแก้ปัญหานี้เหนือกว่าความหลากหลายvolatileหรือ-O0เพราะมันชัดเจนว่าเจตนาของคุณคืออะไร

unsigned char i = 10;
__asm__ volatile ( "loop: subi    %0, 0x01\n\t"
                   "      brne    loop"
                   : "+rm" (i)
                   : /* no inputs */
                   : /* no dirty registers to decleare*/);

นั่นควรทำเคล็ดลับ สิ่งที่ระเหยได้คือการบอกคอมไพเลอร์ "ฉันรู้ว่านี่ไม่ได้ทำอะไรเลยเพียงแค่เก็บไว้และเชื่อใจฉัน" คำว่า "งบ" สามอันนั้นค่อนข้างอธิบายตนเองคุณสามารถใช้รีจิสเตอร์แทน r24 ได้ฉันเชื่อว่าคอมไพเลอร์ชอบการลงทะเบียนต่ำดังนั้นคุณอาจต้องการใช้อันสูง หลังจากครั้งแรกที่:คุณควรจะแสดงรายการตัวแปร c เอาท์พุท (อ่านและเขียน) และไม่มีหลังจากที่สอง:คุณควรจะแสดงรายการตัวแปร c (input) (ronly) อีกครั้งไม่มีและพารามิเตอร์ที่สามคือรายการที่คั่นด้วยเครื่องหมายจุลภาค ในกรณีนี้ r24 ฉันไม่แน่ใจว่าคุณควรรวมการลงทะเบียนสถานะด้วยหรือไม่เนื่องจากการZEROเปลี่ยนแปลงการตั้งค่าสถานะของหลักสูตรฉันไม่ได้รวมไว้ด้วย

แก้ไขคำตอบที่แก้ไขตามที่ขอ OP บางบันทึก

"+rm"ก่อนที่จะ(i)หมายความว่าคุณจะให้คอมไพเลอร์ตัดสินใจที่จะวางฉันในมเอมอรีหรือในR egister เป็นสิ่งที่ดีในกรณีส่วนใหญ่เนื่องจากคอมไพเลอร์สามารถเพิ่มประสิทธิภาพได้ดีขึ้นถ้ามันฟรี ในกรณีของคุณฉันเชื่อว่าคุณต้องการเก็บเฉพาะข้อ จำกัด r เพื่อบังคับให้ฉันลงทะเบียน

คุณสามารถลองทำลูปจริงทำอะไรบางอย่าง ขณะที่มันแปลว่าคอมไพเลอร์พูดอย่างถูกต้องว่า "วงนี้ไม่ทำอะไรเลย - ฉันจะกำจัดมัน"

ดังนั้นคุณสามารถลองสร้างฉันใช้บ่อย:

int i;
for (i = 0; i < 10; i++) {
    asm volatile ("nop");
}

หมายเหตุ: ไม่ใช่เป้าหมายทั้งหมดสำหรับคอมไพเลอร์ gcc ใช้ไวยากรณ์แอสเซมบลีไลน์เดียวกัน - คุณอาจต้องปรับแต่งมันสำหรับเป้าหมายของคุณ

ใช่คุณสามารถสันนิษฐานได้ว่า หากคุณประกาศตัวแปร i ว่าระเหยได้คุณจะต้องบอกคอมไพเลอร์ว่าอย่าปรับให้เหมาะสมกับ i

หลังจากลูปแรกiเป็นค่าคงที่ การเริ่มต้นiและลูปไม่ได้ทำอะไรนอกจากสร้างค่าคงที่ ไม่มีอะไรในมาตรฐานที่ระบุว่าการวนซ้ำนี้จะต้องรวบรวมตามสภาพ มาตรฐานไม่ได้พูดอะไรเกี่ยวกับเวลาเช่นกัน รหัสที่คอมไพล์แล้วจะต้องทำตัวราวกับว่ามีการวนซ้ำอยู่ คุณไม่สามารถบอกได้อย่างน่าเชื่อถือว่าการเพิ่มประสิทธิภาพนี้ดำเนินการภายใต้มาตรฐาน (ไม่นับเวลา)

ควรลบลูปที่สองด้วย ฉันคิดว่าเป็นข้อผิดพลาด (หรือการเพิ่มประสิทธิภาพที่หายไป) ว่าไม่ใช่ หลังจากวนiเป็นศูนย์คงที่ รหัสควรถูกแทนที่ด้วยการตั้งค่าiเป็นศูนย์

ผมคิดว่า GCC ช่วยให้iรอบหมดจดสำหรับเหตุผลที่คุณทำการ (ทึบแสง) iการเข้าถึงพอร์ตอาจส่งผลกระทบต่อ

ใช้

asm volatile ("nop");

เพื่อหลอกลวง GCC ให้เชื่อว่าการวนซ้ำทำอะไรบางอย่าง