This is an archive of the discontinued LLVM Phabricator instance.

Differential D146071

[AIX] unset bit "IsBackChainStored" of traceback table for leaf functions with no stack frame
ClosedPublic

Authored by DiggerLin on Mar 14 2023, 10:50 AM.

Details

Reviewers
hubert.reinterpretcast
shchenz
Commits
rG49bc3077cbf8: [AIX] unset bit "IsBackChainStored" of traceback table for leaf functions with…
Summary

in function PPCAIXAsmPrinter::emitTracebackTable() ,the bit "IsBackChainStored" of traceback table always set true, it will cause aix debug tools "dbx" emit an error info "libdebug assertion "(framep->getGpr(STKP, &addr) == DB_SUCCESS && *nextStkpp == addr)" when debug a leaf functions with no stack frame.

If a a leaf functions with no stack frame , the bit IsBackChainStored should be unset.

Diff Detail

Event Timeline

DiggerLin created this revision.Mar 14 2023, 10:50 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 14 2023, 10:50 AM
Herald added subscribers: kbarton, hiraditya, nemanjai. · View Herald Transcript
DiggerLin requested review of this revision.Mar 14 2023, 10:50 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 14 2023, 10:50 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
Harbormaster completed remote builds in B219405: Diff 505165.Mar 14 2023, 10:52 AM
stephenpeckham added a subscriber: stephenpeckham.Mar 14 2023, 1:11 PM

Are there still tests where IsBackChainStored is true?

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp
2136

Comment no longer applies

shchenz added a subscriber: shchenz.Mar 15 2023, 12:35 AM

We should already have case for leaf/non-leaf functions. Can we also add cases on the boundary conditions for redzone with below MIR?

---
name:            test
tracksRegLiveness: true
stack:
  - { id: 0, size: 288, alignment: 16 }
body: |
  bb.0:
    BLR8 implicit $lr8, implicit $rm
...

288 is redzone size for 64-bit PPC.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp
2137

Are you using the wrong diff baseline? Seems like the left side is a local commit of your working branch? In the main trunk, I see

// Always store back chain.
SecondHalfOfMandatoryField |= TracebackTable::IsBackChainStoredMask;
DiggerLin updated this revision to Diff 505473.Mar 15 2023, 6:41 AM
DiggerLin marked 2 inline comments as done.

fixed part of comment.

DiggerLin added a comment.EditedMar 15 2023, 6:43 AM
In D146071#4194372, @stephenpeckham wrote:

Are there still tests where IsBackChainStored is true?

yes, for example ,in the test llvm/test/CodeGen/PowerPC/aix-emit-tracebacktable.ll , line 177

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp
2136

thanks

2137

yes, left side is working. thanks

Harbormaster completed remote builds in B219621: Diff 505473.Mar 15 2023, 7:58 AM
DiggerLin added inline comments.Mar 15 2023, 10:01 AM
llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp
2137

I git diff again my local branch, it correct now.

DiggerLin updated this revision to Diff 505626.Mar 15 2023, 2:28 PM

add a redzone boundary test case

Harbormaster completed remote builds in B219730: Diff 505626.Mar 15 2023, 3:33 PM
shchenz accepted this revision.Mar 15 2023, 5:47 PM
shchenz edited reviewers, added: shchenz; removed: cezheng.

LGTM. Thanks for improving this.

This revision is now accepted and ready to land.Mar 15 2023, 5:47 PM
Closed by commit rG49bc3077cbf8: [AIX] unset bit "IsBackChainStored" of traceback table for leaf functions with… (authored by zhijian <zhijian@ca.ibm.com>). · Explain WhyMar 16 2023, 12:26 PM
This revision was automatically updated to reflect the committed changes.
zhijian <zhijian@ca.ibm.com> added a commit: rG49bc3077cbf8: [AIX] unset bit "IsBackChainStored" of traceback table for leaf functions with….
DiggerLin mentioned this in D89049: [AIX][XCOFF] print out the traceback info .Apr 20 2023, 7:30 AM

Revision Contents

Diff 505165

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

Show First 20 Lines • Show All 2,127 Lines • ▼ Show 20 Lines#define GENVALUECOMMENT(PrefixAndName, V, Field) \
GENBOOLCOMMENT(", ", FirstHalfOfMandatoryField, IsLRSaved); GENBOOLCOMMENT(", ", FirstHalfOfMandatoryField, IsLRSaved);
EmitComment(); EmitComment();
OutStreamer->emitIntValueInHexWithPadding((FirstHalfOfMandatoryField & 0xff), OutStreamer->emitIntValueInHexWithPadding((FirstHalfOfMandatoryField & 0xff),
1); 1);
// Set the 5th byte of mandatory field. // Set the 5th byte of mandatory field.
uint32_t SecondHalfOfMandatoryField = 0; uint32_t SecondHalfOfMandatoryField = 0;
// Always store back chain. // Always store back chain.
stephenpeckhamUnsubmitted
Done
ReplyInline Actions

Comment no longer applies

stephenpeckham: Comment no longer applies
DiggerLinAuthorUnsubmitted
Done
ReplyInline Actions

thanks

DiggerLin: thanks
SecondHalfOfMandatoryField |= MF->getFrameInfo().getFrameSize() ? TracebackTable::IsBackChainStoredMask : 0; SecondHalfOfMandatoryField |= MF->getFrameInfo().getStackSize()
shchenzUnsubmitted
Done
ReplyInline Actions

Are you using the wrong diff baseline? Seems like the left side is a local commit of your working branch? In the main trunk, I see

// Always store back chain.
SecondHalfOfMandatoryField |= TracebackTable::IsBackChainStoredMask;
shchenz: Are you using the wrong diff baseline? Seems like the left side is a local commit of your…
DiggerLinAuthorUnsubmitted
Done
ReplyInline Actions

yes, left side is working. thanks

DiggerLin: yes, left side is working. thanks
DiggerLinAuthorUnsubmitted
Done
ReplyInline Actions

I git diff again my local branch, it correct now.

DiggerLin: I git diff again my local branch, it correct now.
? TracebackTable::IsBackChainStoredMask
: 0;
uint32_t FPRSaved = 0; uint32_t FPRSaved = 0;
for (unsigned Reg = PPC::F14; Reg <= PPC::F31; ++Reg) { for (unsigned Reg = PPC::F14; Reg <= PPC::F31; ++Reg) {
if (MRI.isPhysRegModified(Reg)) { if (MRI.isPhysRegModified(Reg)) {
FPRSaved = PPC::F31 - Reg + 1; FPRSaved = PPC::F31 - Reg + 1;
break; break;
} }
} }
▲ Show 20 Lines • Show All 748 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/aix-emit-tracebacktable-clobber-register.ll

Show All 40 Lines
; COMMON-NEXT: .byte 0x09 # Language = CPlusPlus ; COMMON-NEXT: .byte 0x09 # Language = CPlusPlus
; COMMON-NEXT: .byte 0x22 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue ; COMMON-NEXT: .byte 0x22 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
; COMMON-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure ; COMMON-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure
; COMMON-NEXT: # -HasControlledStorage, -IsTOCless ; COMMON-NEXT: # -HasControlledStorage, -IsTOCless
; COMMON-NEXT: # +IsFloatingPointPresent ; COMMON-NEXT: # +IsFloatingPointPresent
; COMMON-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled ; COMMON-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled
; COMMON-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed ; COMMON-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
; COMMON-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved ; COMMON-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
; COMMON-NEXT: .byte 0x85 # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 5 ; COMMON-NEXT: .byte 0x05 # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 5
; COMMON-NEXT: .byte 0x04 # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 4 ; COMMON-NEXT: .byte 0x04 # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 4
; COMMON-NEXT: .byte 0x00 # NumberOfFixedParms = 0 ; COMMON-NEXT: .byte 0x00 # NumberOfFixedParms = 0
; COMMON-NEXT: .byte 0x01 # NumberOfFPParms = 0, +HasParmsOnStack ; COMMON-NEXT: .byte 0x01 # NumberOfFPParms = 0, +HasParmsOnStack
; CHECK-ASM-NEXT: .vbyte 4, L..bar0-.bar # Function size ; CHECK-ASM-NEXT: .vbyte 4, L..bar0-.bar # Function size
; CHECK-FUNC-NEXT: .vbyte 4, L..bar0-.bar[PR] # Function size ; CHECK-FUNC-NEXT: .vbyte 4, L..bar0-.bar[PR] # Function size
; COMMON-NEXT: .vbyte 2, 0x0003 # Function name len = 3 ; COMMON-NEXT: .vbyte 2, 0x0003 # Function name len = 3
; COMMON-NEXT: .byte "bar" # Function Name ; COMMON-NEXT: .byte "bar" # Function Name
; COMMON-NEXT: # -- End function ; COMMON-NEXT: # -- End function
; COMMON: L..foov0: ; COMMON: L..foov0:
; COMMON-NEXT: .vbyte 4, 0x00000000 # Traceback table begin ; COMMON-NEXT: .vbyte 4, 0x00000000 # Traceback table begin
; COMMON-NEXT: .byte 0x00 # Version = 0 ; COMMON-NEXT: .byte 0x00 # Version = 0
; COMMON-NEXT: .byte 0x09 # Language = CPlusPlus ; COMMON-NEXT: .byte 0x09 # Language = CPlusPlus
; COMMON-NEXT: .byte 0x20 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue ; COMMON-NEXT: .byte 0x20 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
; COMMON-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure ; COMMON-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure
; COMMON-NEXT: # -HasControlledStorage, -IsTOCless ; COMMON-NEXT: # -HasControlledStorage, -IsTOCless
; COMMON-NEXT: # -IsFloatingPointPresent ; COMMON-NEXT: # -IsFloatingPointPresent
; COMMON-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled ; COMMON-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled
; COMMON-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed ; COMMON-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
; COMMON-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved ; COMMON-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
; COMMON-NEXT: .byte 0x80 # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0 ; COMMON-NEXT: .byte 0x00 # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
; COMMON-NEXT: .byte 0xc0 # +HasExtensionTable, +HasVectorInfo, NumOfGPRsSaved = 0 ; COMMON-NEXT: .byte 0xc0 # +HasExtensionTable, +HasVectorInfo, NumOfGPRsSaved = 0
; COMMON-NEXT: .byte 0x00 # NumberOfFixedParms = 0 ; COMMON-NEXT: .byte 0x00 # NumberOfFixedParms = 0
; COMMON-NEXT: .byte 0x01 # NumberOfFPParms = 0, +HasParmsOnStack ; COMMON-NEXT: .byte 0x01 # NumberOfFPParms = 0, +HasParmsOnStack
; CHECK-ASM-NEXT: .vbyte 4, L..foov0-.foov # Function size ; CHECK-ASM-NEXT: .vbyte 4, L..foov0-.foov # Function size
; CHECK-FUNC-NEXT: .vbyte 4, L..foov0-.foov[PR] # Function size ; CHECK-FUNC-NEXT: .vbyte 4, L..foov0-.foov[PR] # Function size
; COMMON-NEXT: .vbyte 2, 0x0004 # Function name len = 4 ; COMMON-NEXT: .vbyte 2, 0x0004 # Function name len = 4
; COMMON-NEXT: .byte "foov" # Function Name ; COMMON-NEXT: .byte "foov" # Function Name
; COMMON-NEXT: .byte 0x12 # NumOfVRsSaved = 4, +IsVRSavedOnStack, -HasVarArgs ; COMMON-NEXT: .byte 0x12 # NumOfVRsSaved = 4, +IsVRSavedOnStack, -HasVarArgs
Show All 19 Lines

llvm/test/CodeGen/PowerPC/aix-emit-tracebacktable-vectorinfo.ll

Show First 20 Lines • Show All 83 Lines • ▼ Show 20 Lines
; COMMON-NEXT: .byte 0x09 # Language = CPlusPlus ; COMMON-NEXT: .byte 0x09 # Language = CPlusPlus
; COMMON-NEXT: .byte 0x22 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue ; COMMON-NEXT: .byte 0x22 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
; COMMON-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure ; COMMON-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure
; COMMON-NEXT: # -HasControlledStorage, -IsTOCless ; COMMON-NEXT: # -HasControlledStorage, -IsTOCless
; COMMON-NEXT: # +IsFloatingPointPresent ; COMMON-NEXT: # +IsFloatingPointPresent
; COMMON-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled ; COMMON-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled
; COMMON-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed ; COMMON-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
; COMMON-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved ; COMMON-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
; COMMON-NEXT: .byte 0x80 # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0 ; COMMON-NEXT: .byte 0x00 # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
; COMMON-NEXT: .byte 0x40 # -HasExtensionTable, +HasVectorInfo, NumOfGPRsSaved = 0 ; COMMON-NEXT: .byte 0x40 # -HasExtensionTable, +HasVectorInfo, NumOfGPRsSaved = 0
; COMMON-NEXT: .byte 0x02 # NumberOfFixedParms = 2 ; COMMON-NEXT: .byte 0x02 # NumberOfFixedParms = 2
; COMMON-NEXT: .byte 0x05 # NumberOfFPParms = 2, +HasParmsOnStack ; COMMON-NEXT: .byte 0x05 # NumberOfFPParms = 2, +HasParmsOnStack
; COMMON-NEXT: .vbyte 4, 0x42740000 # Parameter type = v, i, i, f, v, d, v ; COMMON-NEXT: .vbyte 4, 0x42740000 # Parameter type = v, i, i, f, v, d, v
; CHECK-ASM-NEXT: .vbyte 4, L..f0-.f # Function size ; CHECK-ASM-NEXT: .vbyte 4, L..f0-.f # Function size
; CHECK-FUNC-NEXT: .vbyte 4, L..f0-.f[PR] # Function size ; CHECK-FUNC-NEXT: .vbyte 4, L..f0-.f[PR] # Function size
; COMMON-NEXT: .vbyte 2, 0x0001 # Function name len = 1 ; COMMON-NEXT: .vbyte 2, 0x0001 # Function name len = 1
; COMMON-NEXT: .byte 102 # Function Name ; COMMON-NEXT: .byte 102 # Function Name
; COMMON-NEXT: .byte 0x00 # NumOfVRsSaved = 0, -IsVRSavedOnStack, -HasVarArgs ; COMMON-NEXT: .byte 0x00 # NumOfVRsSaved = 0, -IsVRSavedOnStack, -HasVarArgs
; COMMON-NEXT: .byte 0x07 # NumOfVectorParams = 3, +HasVMXInstruction ; COMMON-NEXT: .byte 0x07 # NumOfVectorParams = 3, +HasVMXInstruction
; COMMON-NEXT: .vbyte 4, 0xb0000000 # Vector Parameter type = vi, vf, vc ; COMMON-NEXT: .vbyte 4, 0xb0000000 # Vector Parameter type = vi, vf, vc
; COMMON-NEXT: .vbyte 2, 0x0000 # Padding ; COMMON-NEXT: .vbyte 2, 0x0000 # Padding
; COMMON: L..fin0: ; COMMON: L..fin0:
; COMMON-NEXT: .vbyte 4, 0x00000000 # Traceback table begin ; COMMON-NEXT: .vbyte 4, 0x00000000 # Traceback table begin
; COMMON-NEXT: .byte 0x00 # Version = 0 ; COMMON-NEXT: .byte 0x00 # Version = 0
; COMMON-NEXT: .byte 0x09 # Language = CPlusPlus ; COMMON-NEXT: .byte 0x09 # Language = CPlusPlus
; COMMON-NEXT: .byte 0x22 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue ; COMMON-NEXT: .byte 0x22 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
; COMMON-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure ; COMMON-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure
; COMMON-NEXT: # -HasControlledStorage, -IsTOCless ; COMMON-NEXT: # -HasControlledStorage, -IsTOCless
; COMMON-NEXT: # +IsFloatingPointPresent ; COMMON-NEXT: # +IsFloatingPointPresent
; COMMON-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled ; COMMON-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled
; COMMON-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed ; COMMON-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
; COMMON-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved ; COMMON-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
; COMMON-NEXT: .byte 0x80 # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0 ; COMMON-NEXT: .byte 0x00 # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
; COMMON-NEXT: .byte 0x40 # -HasExtensionTable, +HasVectorInfo, NumOfGPRsSaved = 0 ; COMMON-NEXT: .byte 0x40 # -HasExtensionTable, +HasVectorInfo, NumOfGPRsSaved = 0
; COMMON-NEXT: .byte 0x01 # NumberOfFixedParms = 1 ; COMMON-NEXT: .byte 0x01 # NumberOfFixedParms = 1
; COMMON-NEXT: .byte 0x01 # NumberOfFPParms = 0, +HasParmsOnStack ; COMMON-NEXT: .byte 0x01 # NumberOfFPParms = 0, +HasParmsOnStack
; COMMON-NEXT: .vbyte 4, 0x00000000 # Parameter type = i ; COMMON-NEXT: .vbyte 4, 0x00000000 # Parameter type = i
; CHECK-ASM-NEXT: .vbyte 4, L..fin0-.fin # Function size ; CHECK-ASM-NEXT: .vbyte 4, L..fin0-.fin # Function size
; CHECK-FUNC-NEXT: .vbyte 4, L..fin0-.fin[PR] # Function size ; CHECK-FUNC-NEXT: .vbyte 4, L..fin0-.fin[PR] # Function size
; COMMON-NEXT: .vbyte 2, 0x0003 # Function name len = 3 ; COMMON-NEXT: .vbyte 2, 0x0003 # Function name len = 3
; COMMON-NEXT: .byte "fin" # Function Name ; COMMON-NEXT: .byte "fin" # Function Name
; COMMON-NEXT: .byte 0x00 # NumOfVRsSaved = 0, -IsVRSavedOnStack, -HasVarArgs ; COMMON-NEXT: .byte 0x00 # NumOfVRsSaved = 0, -IsVRSavedOnStack, -HasVarArgs
; COMMON-NEXT: .byte 0x01 # NumOfVectorParams = 0, +HasVMXInstruction ; COMMON-NEXT: .byte 0x01 # NumOfVectorParams = 0, +HasVMXInstruction
; COMMON-NEXT: .vbyte 4, 0x00000000 # Vector Parameter type = ; COMMON-NEXT: .vbyte 4, 0x00000000 # Vector Parameter type =
; COMMON-NEXT: .vbyte 2, 0x0000 # Padding ; COMMON-NEXT: .vbyte 2, 0x0000 # Padding

llvm/test/CodeGen/PowerPC/aix-emit-tracebacktable-vectorinfo_hasvarg.ll

Show All 16 Lines
;CHECK-ASM-NEXT: .byte 0x09 # Language = CPlusPlus ;CHECK-ASM-NEXT: .byte 0x09 # Language = CPlusPlus
;CHECK-ASM-NEXT: .byte 0x20 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue ;CHECK-ASM-NEXT: .byte 0x20 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
;CHECK-ASM-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure ;CHECK-ASM-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure
;CHECK-ASM-NEXT: # -HasControlledStorage, -IsTOCless ;CHECK-ASM-NEXT: # -HasControlledStorage, -IsTOCless
;CHECK-ASM-NEXT: # -IsFloatingPointPresent ;CHECK-ASM-NEXT: # -IsFloatingPointPresent
;CHECK-ASM-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled ;CHECK-ASM-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled
;CHECK-ASM-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed ;CHECK-ASM-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
;CHECK-ASM-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved ;CHECK-ASM-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
;CHECK-ASM-NEXT: .byte 0x80 # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0 ;CHECK-ASM-NEXT: .byte 0x00 # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
;CHECK-ASM-NEXT: .byte 0x40 # -HasExtensionTable, +HasVectorInfo, NumOfGPRsSaved = 0 ;CHECK-ASM-NEXT: .byte 0x40 # -HasExtensionTable, +HasVectorInfo, NumOfGPRsSaved = 0
;CHECK-ASM-NEXT: .byte 0x00 # NumberOfFixedParms = 0 ;CHECK-ASM-NEXT: .byte 0x00 # NumberOfFixedParms = 0
;CHECK-ASM-NEXT: .byte 0x01 # NumberOfFPParms = 0, +HasParmsOnStack ;CHECK-ASM-NEXT: .byte 0x01 # NumberOfFPParms = 0, +HasParmsOnStack
;CHECK-ASM-NEXT: .vbyte 4, L..f0-.f # Function size ;CHECK-ASM-NEXT: .vbyte 4, L..f0-.f # Function size
;CHECK-ASM-NEXT: .vbyte 2, 0x0001 # Function name len = 1 ;CHECK-ASM-NEXT: .vbyte 2, 0x0001 # Function name len = 1
;CHECK-ASM-NEXT: .byte 102 # Function Name ;CHECK-ASM-NEXT: .byte 102 # Function Name
;CHECK-ASM-NEXT: .byte 0x01 # NumOfVRsSaved = 0, -IsVRSavedOnStack, +HasVarArgs ;CHECK-ASM-NEXT: .byte 0x01 # NumOfVRsSaved = 0, -IsVRSavedOnStack, +HasVarArgs
;CHECK-ASM-NEXT: .byte 0x03 # NumOfVectorParams = 1, +HasVMXInstruction ;CHECK-ASM-NEXT: .byte 0x03 # NumOfVectorParams = 1, +HasVMXInstruction
;CHECK-ASM-NEXT: .vbyte 4, 0xc0000000 # Vector Parameter type = vf ;CHECK-ASM-NEXT: .vbyte 4, 0xc0000000 # Vector Parameter type = vf
;CHECK-ASM-NEXT: .vbyte 2, 0x0000 # Padding ;CHECK-ASM-NEXT: .vbyte 2, 0x0000 # Padding
;CHECK-ASM-NEXT: # -- End function ;CHECK-ASM-NEXT: # -- End function

llvm/test/CodeGen/PowerPC/aix-emit-tracebacktable.ll

Show First 20 Lines • Show All 139 Lines • ▼ Show 20 Lines
; COMMON-NEXT: .byte 0x09 # Language = CPlusPlus ; COMMON-NEXT: .byte 0x09 # Language = CPlusPlus
; COMMON-NEXT: .byte 0x22 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue ; COMMON-NEXT: .byte 0x22 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
; COMMON-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure ; COMMON-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure
; COMMON-NEXT: # -HasControlledStorage, -IsTOCless ; COMMON-NEXT: # -HasControlledStorage, -IsTOCless
; COMMON-NEXT: # +IsFloatingPointPresent ; COMMON-NEXT: # +IsFloatingPointPresent
; COMMON-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled ; COMMON-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled
; COMMON-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed ; COMMON-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
; COMMON-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved ; COMMON-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
; COMMON-NEXT: .byte 0x80 # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0 ; COMMON-NEXT: .byte 0x00 # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
; COMMON-NEXT: .byte 0x00 # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0 ; COMMON-NEXT: .byte 0x00 # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0
; COMMON-NEXT: .byte 0x05 # NumberOfFixedParms = 5 ; COMMON-NEXT: .byte 0x05 # NumberOfFixedParms = 5
; COMMON-NEXT: .byte 0x05 # NumberOfFPParms = 2, +HasParmsOnStack ; COMMON-NEXT: .byte 0x05 # NumberOfFPParms = 2, +HasParmsOnStack
; COMMON-NEXT: .vbyte 4, 0x58000000 # Parameter type = i, f, d, i, i, i, i ; COMMON-NEXT: .vbyte 4, 0x58000000 # Parameter type = i, f, d, i, i, i, i
; CHECK-ASM-NEXT: .vbyte 4, L.._Z10add_structifd1SP2SD1Di0-._Z10add_structifd1SP2SD1Di # Function size ; CHECK-ASM-NEXT: .vbyte 4, L.._Z10add_structifd1SP2SD1Di0-._Z10add_structifd1SP2SD1Di # Function size
; CHECK-FUNC-NEXT: .vbyte 4, L.._Z10add_structifd1SP2SD1Di0-._Z10add_structifd1SP2SD1Di[PR] # Function size ; CHECK-FUNC-NEXT: .vbyte 4, L.._Z10add_structifd1SP2SD1Di0-._Z10add_structifd1SP2SD1Di[PR] # Function size
; COMMON-NEXT: .vbyte 2, 0x001a # Function name len = 26 ; COMMON-NEXT: .vbyte 2, 0x001a # Function name len = 26
; COMMON-NEXT: .byte "_Z10add_structifd1SP2SD1Di" # Function Name ; COMMON-NEXT: .byte "_Z10add_structifd1SP2SD1Di" # Function Name
Show All 35 Lines
; COMMON-NEXT: .byte 0x09 # Language = CPlusPlus ; COMMON-NEXT: .byte 0x09 # Language = CPlusPlus
; COMMON-NEXT: .byte 0x22 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue ; COMMON-NEXT: .byte 0x22 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
; COMMON-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure ; COMMON-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure
; COMMON-NEXT: # -HasControlledStorage, -IsTOCless ; COMMON-NEXT: # -HasControlledStorage, -IsTOCless
; COMMON-NEXT: # +IsFloatingPointPresent ; COMMON-NEXT: # +IsFloatingPointPresent
; COMMON-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled ; COMMON-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled
; COMMON-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed ; COMMON-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
; COMMON-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved ; COMMON-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
; COMMON-NEXT: .byte 0x80 # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0 ; COMMON-NEXT: .byte 0x00 # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
; COMMON-NEXT: .byte 0x00 # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0 ; COMMON-NEXT: .byte 0x00 # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0
; COMMON-NEXT: .byte 0x05 # NumberOfFixedParms = 5 ; COMMON-NEXT: .byte 0x05 # NumberOfFixedParms = 5
; COMMON-NEXT: .byte 0x05 # NumberOfFPParms = 2, +HasParmsOnStack ; COMMON-NEXT: .byte 0x05 # NumberOfFPParms = 2, +HasParmsOnStack
; COMMON-NEXT: .vbyte 4, 0x16000000 # Parameter type = i, i, i, f, d, i, i ; COMMON-NEXT: .vbyte 4, 0x16000000 # Parameter type = i, i, i, f, d, i, i
; CHECK-ASM-NEXT: .vbyte 4, L.._Z7add_bari1SfdP2SD1Di0-._Z7add_bari1SfdP2SD1Di # Function size ; CHECK-ASM-NEXT: .vbyte 4, L.._Z7add_bari1SfdP2SD1Di0-._Z7add_bari1SfdP2SD1Di # Function size
; CHECK-FUNC-NEXT: .vbyte 4, L.._Z7add_bari1SfdP2SD1Di0-._Z7add_bari1SfdP2SD1Di[PR] # Function size ; CHECK-FUNC-NEXT: .vbyte 4, L.._Z7add_bari1SfdP2SD1Di0-._Z7add_bari1SfdP2SD1Di[PR] # Function size
; COMMON-NEXT: .vbyte 2, 0x0016 # Function name len = 22 ; COMMON-NEXT: .vbyte 2, 0x0016 # Function name len = 22
; COMMON-NEXT: .byte "_Z7add_bari1SfdP2SD1Di" # Function Name ; COMMON-NEXT: .byte "_Z7add_bari1SfdP2SD1Di" # Function Name
Show All 10 Lines
; COMMON-NEXT: .byte 0x09 # Language = CPlusPlus ; COMMON-NEXT: .byte 0x09 # Language = CPlusPlus
; COMMON-NEXT: .byte 0x20 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue ; COMMON-NEXT: .byte 0x20 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
; COMMON-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure ; COMMON-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure
; COMMON-NEXT: # -HasControlledStorage, -IsTOCless ; COMMON-NEXT: # -HasControlledStorage, -IsTOCless
; COMMON-NEXT: # -IsFloatingPointPresent ; COMMON-NEXT: # -IsFloatingPointPresent
; COMMON-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled ; COMMON-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled
; COMMON-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed ; COMMON-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
; COMMON-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved ; COMMON-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
; COMMON-NEXT: .byte 0x80 # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0 ; COMMON-NEXT: .byte 0x00 # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
; COMMON-NEXT: .byte 0x00 # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0 ; COMMON-NEXT: .byte 0x00 # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0
; COMMON-NEXT: .byte 0x07 # NumberOfFixedParms = 7 ; COMMON-NEXT: .byte 0x07 # NumberOfFixedParms = 7
; COMMON-NEXT: .byte 0x1b # NumberOfFPParms = 13, +HasParmsOnStack ; COMMON-NEXT: .byte 0x1b # NumberOfFPParms = 13, +HasParmsOnStack
; COMMON-NEXT: .vbyte 4, 0x01555554 # Parameter type = i, i, i, i, i, i, i, f, f, f, f, f, f, f, f, f, f, f, f, ... ; COMMON-NEXT: .vbyte 4, 0x01555554 # Parameter type = i, i, i, i, i, i, i, f, f, f, f, f, f, f, f, f, f, f, f, ...
; CHECK-ASM-NEXT: .vbyte 4, L..foo0-.foo # Function size ; CHECK-ASM-NEXT: .vbyte 4, L..foo0-.foo # Function size
; CHECK-FUNC-NEXT: .vbyte 4, L..foo0-.foo[PR] # Function size ; CHECK-FUNC-NEXT: .vbyte 4, L..foo0-.foo[PR] # Function size
; COMMON-NEXT: .vbyte 2, 0x0003 # Function name len = 3 ; COMMON-NEXT: .vbyte 2, 0x0003 # Function name len = 3
; COMMON-NEXT: .byte "foo" # Function Name ; COMMON-NEXT: .byte "foo" # Function Name
; COMMON-NEXT: # -- End function ; COMMON-NEXT: # -- End function

llvm/test/DebugInfo/XCOFF/empty.ll

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Lines
; ASM32-NEXT: .byte 0x09 # Language = CPlusPlus ; ASM32-NEXT: .byte 0x09 # Language = CPlusPlus
; ASM32-NEXT: .byte 0x20 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue ; ASM32-NEXT: .byte 0x20 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
; ASM32-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure ; ASM32-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure
; ASM32-NEXT: # -HasControlledStorage, -IsTOCless ; ASM32-NEXT: # -HasControlledStorage, -IsTOCless
; ASM32-NEXT: # -IsFloatingPointPresent ; ASM32-NEXT: # -IsFloatingPointPresent
; ASM32-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled ; ASM32-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled
; ASM32-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed ; ASM32-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
; ASM32-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved ; ASM32-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
; ASM32-NEXT: .byte 0x80 # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0 ; ASM32-NEXT: .byte 0x00 # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
; ASM32-NEXT: .byte 0x00 # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0 ; ASM32-NEXT: .byte 0x00 # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0
; ASM32-NEXT: .byte 0x00 # NumberOfFixedParms = 0 ; ASM32-NEXT: .byte 0x00 # NumberOfFixedParms = 0
; ASM32-NEXT: .byte 0x01 # NumberOfFPParms = 0, +HasParmsOnStack ; ASM32-NEXT: .byte 0x01 # NumberOfFPParms = 0, +HasParmsOnStack
; ASM32-NEXT: .vbyte 4, L..main0-.main # Function size ; ASM32-NEXT: .vbyte 4, L..main0-.main # Function size
; ASM32-NEXT: .vbyte 2, 0x0004 # Function name len = 4 ; ASM32-NEXT: .vbyte 2, 0x0004 # Function name len = 4
; ASM32-NEXT: .byte "main" # Function Name ; ASM32-NEXT: .byte "main" # Function Name
; ASM32-NEXT: L..func_end0: ; ASM32-NEXT: L..func_end0:
; ASM32-NEXT: # -- End function ; ASM32-NEXT: # -- End function
▲ Show 20 Lines • Show All 184 Lines • ▼ Show 20 Lines
; ASM64-NEXT: .byte 0x09 # Language = CPlusPlus ; ASM64-NEXT: .byte 0x09 # Language = CPlusPlus
; ASM64-NEXT: .byte 0x20 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue ; ASM64-NEXT: .byte 0x20 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
; ASM64-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure ; ASM64-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure
; ASM64-NEXT: # -HasControlledStorage, -IsTOCless ; ASM64-NEXT: # -HasControlledStorage, -IsTOCless
; ASM64-NEXT: # -IsFloatingPointPresent ; ASM64-NEXT: # -IsFloatingPointPresent
; ASM64-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled ; ASM64-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled
; ASM64-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed ; ASM64-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
; ASM64-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved ; ASM64-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
; ASM64-NEXT: .byte 0x80 # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0 ; ASM64-NEXT: .byte 0x00 # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
; ASM64-NEXT: .byte 0x00 # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0 ; ASM64-NEXT: .byte 0x00 # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0
; ASM64-NEXT: .byte 0x00 # NumberOfFixedParms = 0 ; ASM64-NEXT: .byte 0x00 # NumberOfFixedParms = 0
; ASM64-NEXT: .byte 0x01 # NumberOfFPParms = 0, +HasParmsOnStack ; ASM64-NEXT: .byte 0x01 # NumberOfFPParms = 0, +HasParmsOnStack
; ASM64-NEXT: .vbyte 4, L..main0-.main # Function size ; ASM64-NEXT: .vbyte 4, L..main0-.main # Function size
; ASM64-NEXT: .vbyte 2, 0x0004 # Function name len = 4 ; ASM64-NEXT: .vbyte 2, 0x0004 # Function name len = 4
; ASM64-NEXT: .byte "main" # Function Name ; ASM64-NEXT: .byte "main" # Function Name
; ASM64-NEXT: L..func_end0: ; ASM64-NEXT: L..func_end0:
; ASM64-NEXT: # -- End function ; ASM64-NEXT: # -- End function
▲ Show 20 Lines • Show All 245 Lines • Show Last 20 Lines

llvm/test/DebugInfo/XCOFF/explicit-section.ll

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines
; CHECK-NEXT: .byte 0x09 # Language = CPlusPlus ; CHECK-NEXT: .byte 0x09 # Language = CPlusPlus
; CHECK-NEXT: .byte 0x20 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue ; CHECK-NEXT: .byte 0x20 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
; CHECK-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure ; CHECK-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure
; CHECK-NEXT: # -HasControlledStorage, -IsTOCless ; CHECK-NEXT: # -HasControlledStorage, -IsTOCless
; CHECK-NEXT: # -IsFloatingPointPresent ; CHECK-NEXT: # -IsFloatingPointPresent
; CHECK-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled ; CHECK-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled
; CHECK-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed ; CHECK-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
; CHECK-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved ; CHECK-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
; CHECK-NEXT: .byte 0x80 # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0 ; CHECK-NEXT: .byte 0x00 # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
; CHECK-NEXT: .byte 0x00 # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0 ; CHECK-NEXT: .byte 0x00 # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0
; CHECK-NEXT: .byte 0x00 # NumberOfFixedParms = 0 ; CHECK-NEXT: .byte 0x00 # NumberOfFixedParms = 0
; CHECK-NEXT: .byte 0x01 # NumberOfFPParms = 0, +HasParmsOnStack ; CHECK-NEXT: .byte 0x01 # NumberOfFPParms = 0, +HasParmsOnStack
; CHECK-NEXT: .vbyte 4, L..bar0-.bar # Function size ; CHECK-NEXT: .vbyte 4, L..bar0-.bar # Function size
; CHECK-NEXT: .vbyte 2, 0x0003 # Function name len = 3 ; CHECK-NEXT: .vbyte 2, 0x0003 # Function name len = 3
; CHECK-NEXT: .byte "bar" # Function Name ; CHECK-NEXT: .byte "bar" # Function Name
; CHECK-NEXT: L..func_end0: ; CHECK-NEXT: L..func_end0:
; CHECK-NEXT: # -- End function ; CHECK-NEXT: # -- End function
▲ Show 20 Lines • Show All 256 Lines • Show Last 20 Lines

llvm/test/DebugInfo/XCOFF/function-sections.ll

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
; CHECK-NEXT: .byte 0x09 # Language = CPlusPlus ; CHECK-NEXT: .byte 0x09 # Language = CPlusPlus
; CHECK-NEXT: .byte 0x20 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue ; CHECK-NEXT: .byte 0x20 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
; CHECK-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure ; CHECK-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure
; CHECK-NEXT: # -HasControlledStorage, -IsTOCless ; CHECK-NEXT: # -HasControlledStorage, -IsTOCless
; CHECK-NEXT: # -IsFloatingPointPresent ; CHECK-NEXT: # -IsFloatingPointPresent
; CHECK-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled ; CHECK-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled
; CHECK-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed ; CHECK-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
; CHECK-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved ; CHECK-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
; CHECK-NEXT: .byte 0x80 # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0 ; CHECK-NEXT: .byte 0x00 # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
; CHECK-NEXT: .byte 0x00 # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0 ; CHECK-NEXT: .byte 0x00 # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0
; CHECK-NEXT: .byte 0x00 # NumberOfFixedParms = 0 ; CHECK-NEXT: .byte 0x00 # NumberOfFixedParms = 0
; CHECK-NEXT: .byte 0x01 # NumberOfFPParms = 0, +HasParmsOnStack ; CHECK-NEXT: .byte 0x01 # NumberOfFPParms = 0, +HasParmsOnStack
; CHECK-NEXT: .vbyte 4, L..foo0-.foo[PR] # Function size ; CHECK-NEXT: .vbyte 4, L..foo0-.foo[PR] # Function size
; CHECK-NEXT: .vbyte 2, 0x0003 # Function name len = 3 ; CHECK-NEXT: .vbyte 2, 0x0003 # Function name len = 3
; CHECK-NEXT: .byte "foo" # Function Name ; CHECK-NEXT: .byte "foo" # Function Name
; CHECK-NEXT: L..func_end0: ; CHECK-NEXT: L..func_end0:
; CHECK-NEXT: # -- End function ; CHECK-NEXT: # -- End function
Show All 19 Lines
; CHECK-NEXT: .byte 0x09 # Language = CPlusPlus ; CHECK-NEXT: .byte 0x09 # Language = CPlusPlus
; CHECK-NEXT: .byte 0x20 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue ; CHECK-NEXT: .byte 0x20 # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
; CHECK-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure ; CHECK-NEXT: # +HasTraceBackTableOffset, -IsInternalProcedure
; CHECK-NEXT: # -HasControlledStorage, -IsTOCless ; CHECK-NEXT: # -HasControlledStorage, -IsTOCless
; CHECK-NEXT: # -IsFloatingPointPresent ; CHECK-NEXT: # -IsFloatingPointPresent
; CHECK-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled ; CHECK-NEXT: # -IsFloatingPointOperationLogOrAbortEnabled
; CHECK-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed ; CHECK-NEXT: .byte 0x40 # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
; CHECK-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved ; CHECK-NEXT: # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
; CHECK-NEXT: .byte 0x80 # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0 ; CHECK-NEXT: .byte 0x00 # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
; CHECK-NEXT: .byte 0x00 # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0 ; CHECK-NEXT: .byte 0x00 # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0
; CHECK-NEXT: .byte 0x00 # NumberOfFixedParms = 0 ; CHECK-NEXT: .byte 0x00 # NumberOfFixedParms = 0
; CHECK-NEXT: .byte 0x01 # NumberOfFPParms = 0, +HasParmsOnStack ; CHECK-NEXT: .byte 0x01 # NumberOfFPParms = 0, +HasParmsOnStack
; CHECK-NEXT: .vbyte 4, L..bar0-.bar[PR] # Function size ; CHECK-NEXT: .vbyte 4, L..bar0-.bar[PR] # Function size
; CHECK-NEXT: .vbyte 2, 0x0003 # Function name len = 3 ; CHECK-NEXT: .vbyte 2, 0x0003 # Function name len = 3
; CHECK-NEXT: .byte "bar" # Function Name ; CHECK-NEXT: .byte "bar" # Function Name
; CHECK-NEXT: L..func_end1: ; CHECK-NEXT: L..func_end1:
; CHECK-NEXT: # -- End function ; CHECK-NEXT: # -- End function
▲ Show 20 Lines • Show All 202 Lines • Show Last 20 Lines