ฉันจะบอก gcc ไม่ให้อินไลน์ฟังก์ชันได้อย่างไร

สมมติว่าฉันมีฟังก์ชันเล็ก ๆ นี้ในไฟล์ต้นฉบับ

static void foo() {}

และฉันสร้างไบนารีเวอร์ชันที่ปรับให้เหมาะสมแล้ว แต่ฉันไม่ต้องการให้ฟังก์ชันนี้อินไลน์ (เพื่อวัตถุประสงค์ในการเพิ่มประสิทธิภาพ) มีมาโครที่ฉันสามารถเพิ่มในซอร์สโค้ดเพื่อป้องกันการแทรกในหรือไม่

คุณต้องการแอตทริบิวต์gcc-specificnoinline

แอตทริบิวต์ของฟังก์ชันนี้ป้องกันไม่ให้พิจารณาฟังก์ชันสำหรับการแทรกใน หากฟังก์ชันไม่มีผลข้างเคียงจะมีการเพิ่มประสิทธิภาพอื่น ๆ นอกเหนือจากการแทรกในที่ทำให้การเรียกฟังก์ชันถูกปรับให้เหมาะสมแม้ว่าการเรียกฟังก์ชันจะใช้งานอยู่ เพื่อป้องกันไม่ให้การโทรดังกล่าวถูกเพิ่มประสิทธิภาพให้วาง asm ("");

ใช้แบบนี้:

void __attribute__ ((noinline)) foo() 
{
  ...
}

GCC มีสวิตช์ที่เรียกว่า

-fno-inline-small-functions

ดังนั้นใช้เมื่อเรียกใช้ gcc แต่ผลข้างเคียงคือฟังก์ชั่นเล็ก ๆ อื่น ๆ ทั้งหมดจะไม่อยู่ในบรรทัดเดียวกัน

วิธีแบบพกพาในการทำเช่นนี้คือการเรียกใช้ฟังก์ชันผ่านตัวชี้:

void (*foo_ptr)() = foo;
foo_ptr();

แม้ว่าสิ่งนี้จะให้คำแนะนำที่แตกต่างกันไปในการแยกสาขาซึ่งอาจไม่ใช่เป้าหมายของคุณ ซึ่งจะทำให้เป็นจุดที่ดี: สิ่งที่เป็นเป้าหมายของคุณที่นี่?

ฉันรู้ว่าคำถามนั้นเกี่ยวกับ GCC แต่ฉันคิดว่าการมีข้อมูลเกี่ยวกับคอมไพเลอร์คอมไพเลอร์อื่น ๆ อาจเป็นประโยชน์เช่นกัน

noinline คุณลักษณะฟังก์ชันของ GCC นั้นค่อนข้างเป็นที่นิยมในหมู่คอมไพเลอร์อื่น ๆ เช่นกัน ได้รับการสนับสนุนอย่างน้อย:

• เสียงดัง (ตรวจสอบด้วย__has_attribute(noinline))
• คอมไพเลอร์ Intel C / C ++ (เอกสารของพวกเขาแย่มาก แต่ฉันมั่นใจว่ามันใช้ได้กับ 16.0+)
• Oracle Solaris Studio กลับไปเป็นอย่างน้อย 12.2
• ARM C / C ++ คอมไพเลอร์กลับไปเป็นอย่างน้อย 4.1
• IBM XL C / C ++ กลับไปเป็นอย่างน้อย 10.1
• TI 8.0+ (หรือ 7.3+ พร้อม --gcc ซึ่งจะกำหนด__TI_GNU_ATTRIBUTE_SUPPORT__)

นอกจากนี้ MSVC ยังสนับสนุน __declspec(noinline) กลับไปที่ Visual Studio 7.1 Intel อาจรองรับด้วย (พยายามเข้ากันได้กับทั้ง GCC และ MSVC) แต่ฉันไม่ได้ใส่ใจที่จะตรวจสอบสิ่งนั้น โดยพื้นฐานแล้วไวยากรณ์จะเหมือนกัน:

__declspec(noinline)
static void foo(void) { }

PGI 10.2+ (และอาจเก่ากว่า) รองรับnoinlinepragma ซึ่งใช้กับฟังก์ชันถัดไป:

#pragma noinline
static void foo(void) { }

TI 6.0+ รองรับ FUNC_CANNOT_INLINE pragma ซึ่ง (น่ารำคาญ) ทำงานต่างกันใน C และ C ++ ใน C ++ คล้ายกับของ PGI:

#pragma FUNC_CANNOT_INLINE;
static void foo(void) { }

อย่างไรก็ตามใน C ต้องระบุชื่อฟังก์ชัน:

#pragma FUNC_CANNOT_INLINE(foo);
static void foo(void) { }

Cray 6.4+ (และอาจก่อนหน้านี้) ใช้แนวทางที่คล้ายกันโดยต้องใช้ชื่อฟังก์ชัน:

#pragma _CRI inline_never foo
static void foo(void) { }

Oracle Developer Studio ยังสนับสนุน pragma ซึ่งใช้ชื่อฟังก์ชันโดยย้อนกลับไปอย่างน้อย Forte Developer 6แต่โปรดทราบว่าจำเป็นต้องมาหลังจากการประกาศแม้ในเวอร์ชันล่าสุด:

static void foo(void);
#pragma no_inline(foo)

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

ถ้า OTOH คุณโอเคกับบางสิ่งบางอย่างที่เหมาะกับคนส่วนใหญ่คุณสามารถหลีกหนีจากสิ่งที่น่าพึงพอใจเล็กน้อยและไม่จำเป็นต้องทำซ้ำตัวเอง นั่นคือแนวทางที่ฉันใช้สำหรับHedleyซึ่งเวอร์ชันปัจจุบันของ HEDLEY_NEVER_INLINE มีลักษณะดังนี้:

#if \
  HEDLEY_GNUC_HAS_ATTRIBUTE(noinline,4,0,0) || \
  HEDLEY_INTEL_VERSION_CHECK(16,0,0) || \
  HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
  HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
  HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
  HEDLEY_TI_VERSION_CHECK(8,0,0) || \
  (HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
#  define HEDLEY_NEVER_INLINE __attribute__((__noinline__))
#elif HEDLEY_MSVC_VERSION_CHECK(13,10,0)
#  define HEDLEY_NEVER_INLINE __declspec(noinline)
#elif HEDLEY_PGI_VERSION_CHECK(10,2,0)
#  define HEDLEY_NEVER_INLINE _Pragma("noinline")
#elif HEDLEY_TI_VERSION_CHECK(6,0,0)
#  define HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
#else
#  define HEDLEY_NEVER_INLINE HEDLEY_INLINE
#endif

หากคุณไม่ต้องการใช้ Hedley (เป็นโดเมนสาธารณะเดียว / ส่วนหัว CC0) คุณสามารถแปลงมาโครการตรวจสอบเวอร์ชันได้โดยไม่ต้องใช้ความพยายามมากเกินไป แต่ฉันเต็มใจที่จะใส่มากกว่า☺

ในกรณีที่คุณได้รับข้อผิดพลาดของคอมไพเลอร์__attribute__((noinline))คุณสามารถลอง:

noinline int func(int arg)
{
    ....
}

static __attribute__ ((noinline))  void foo()
{

}

นี่คือสิ่งที่ได้ผลสำหรับฉัน

ใช้noinline แอตทริบิวต์ :

int func(int arg) __attribute__((noinline))
{
}

คุณควรใช้ทั้งสองอย่างเมื่อคุณประกาศฟังก์ชันสำหรับการใช้งานภายนอกและเมื่อคุณเขียนฟังก์ชัน

ฉันทำงานกับ gcc 7.2 ฉันต้องการฟังก์ชั่นที่ไม่อินไลน์เป็นพิเศษเพราะต้องสร้างอินสแตนซ์ในไลบรารี ฉันลอง__attribute__((noinline))คำตอบและasm("")คำตอบ ไม่มีใครแก้ปัญหา

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

นี่เป็นกลอุบายสกปรก แต่ได้ผล