C / C++ / MFC

Michael Schubert14-Jul-08 5:44

Michael Schubert

14-Jul-08 5:44

I envy your patience Smile | :)

CPallini14-Jul-08 9:42

CPallini

14-Jul-08 9:42

Duty, sir!
Big Grin | :-D

If the Lord God Almighty had consulted me before embarking upon the Creation, I would have recommended something simpler.
-- Alfonso the Wise, 13th Century King of Castile.

This is going on my arrogant assumptions. You may have a superb reason why I'm completely wrong.
-- Iain Clarke

[My articles]

kDevloper14-Jul-08 0:18

kDevloper

14-Jul-08 0:18

Do you have installed the trial version?

pavya_Cool14-Jul-08 1:20

pavya_Cool

14-Jul-08 1:20

No, its not a trial version.

Pravin

kDevloper14-Jul-08 1:30

kDevloper

14-Jul-08 1:30

Can you please list down the files installed in the folder!

pavya_Cool14-Jul-08 1:53

pavya_Cool

14-Jul-08 1:53

dxsdk
-Bin
-Doc
-Include
-Lib
-Redist
-Samples
-SDKDev
-dxreadme

Pravin

Mark Salsbery14-Jul-08 6:03

Mark Salsbery

14-Jul-08 6:03

That's because DirectShow is no longer part of the DirectX SDK.

You need the Platform SDK for Server 2003 R2 or better.
Then you need to build the DirectShow base class libraries found
in the missing folder.
Then you need to change your project settings to use the new folder
in the PSDK and use your newly built base-classes libraries.

It's all in the documentation!

Mark

Mark Salsbery
Microsoft MVP - Visual C++
Java | [Coffee]

pavya_Cool14-Jul-08 18:48

pavya_Cool

14-Jul-08 18:48

Thanks Mark

Pravin

David Crow14-Jul-08 8:33

David Crow

14-Jul-08 8:33

pavya_Cool wrote:
...but i am not able to search it.

Why not? Since you know the absolute path that the linker is looking for the file in, can't you just browse to that location in Windows Explorer?

"Love people and use things, not love things and use people." - Unknown

"To have a respect for ourselves guides our morals; to have deference for others governs our manners." - Laurence Sterne

input parameter debug

George_George13-Jul-08 22:50

13-Jul-08 22:50

Hello everyone,

I an setting break point on some some system API, for example, CoInitializeEx. Here is the call stack I got from WinDbg.

My question is, how to get the related assembly language before we call CoInitialize (e.g. preparing input parameter), I want to see how the parameters are prepared either in register or pushed on stack for function call CoInitializeEx.

Child-SP          RetAddr           Call Site
00000000`0012f7c8 00000000`023b6744 ole32!CoInitializeEx
00000000`0012f7d0 00000642`7f5f84a6 vfbasics!AVrfpCoInitializeEx+0x2c
00000000`0012f800 00000642`7f622fba mscorwks!Thread::SetApartment+0x8a
00000000`0012f890 00000642`7f5ef820 mscorwks!SystemDomain::SetThreadAptState+0x7e
00000000`0012f8d0 00000642`7f467d97 mscorwks!SystemDomain::ExecuteMainMethod+0x198
00000000`0012fea0 00000642`7f482c24 mscorwks!ExecuteEXE+0x47
00000000`0012fef0 00000642`7ee69ade mscorwks!_CorExeMain+0xac
00000000`0012ff50 00000000`77d5964c mscoree!_CorExeMain+0x3e
00000000`0012ff80 00000000`00000000 KERNEL32!BaseProcessStart+0x29

thanks in advance,
George

Matthew Faithfull14-Jul-08 0:40

Matthew Faithfull

14-Jul-08 0:40

First you need to bring up the call stack window in the debugger, then double click on the calling function. If this doesn't immediately show you the disassembly then you probably need to open the disassembly view window manually. Having said that this looks like .NET code so I've no idea whether what you get will be IL, assembly or just a mess. It all depends on the vagueries of the JIT Compiler I suppose.

"The secret of happiness is freedom, and the secret of freedom, courage."
Thucydides (B.C. 460-400)

George_George14-Jul-08 16:12

14-Jul-08 16:12

Hi Matthew,

I agree with you that using pure native program is better. I just randomly choose a program and practise debugging. Smile | :)

Here is related stack dump and source codes, you can see it is wrong in debugger for input parameter values. Any ideas? Can you reproduce (I am using Windows Server 2003 x64 + VS 2008)?

0:000> kp
Child-SP          RetAddr           Call Site
00000000`0012ff18 00000001`4000100e ole32!CoInitializeEx(void * pMalloc = 0x00000034`00000008, unsigned long flags = 0x184) 
00000000`0012ff20 00000001`400011d2 TestCoInitializeEx1!main(void)+0xe
00000000`0012ff50 00000000`77d5964c TestCoInitializeEx1!__tmainCRTStartup(void)+0x11a
00000000`0012ff80 00000000`00000000 kernel32!BaseProcessStart(<function> * lpStartAddress = 0x00000001`40001320)+0x29


#include <windows.h>
#include <objbase.h>

int main()
{
	CoInitializeEx(NULL, 0);

	CoUninitialize();

	return 0;
}

regards,
George

Matthew Faithfull15-Jul-08 0:42

Matthew Faithfull

15-Jul-08 0:42

What you've posted is the Call Stack, which is useful, as you've now got the address of the stack so you could look at it in the memory window. What you're looking for though is the disassembly window which will show you the assembly level code around the call from main to CoInitializeEx. Remember that which parameters are passed in which registers, if any and which are pushed and popped on the stack is not only Compiler depenedent but also dependent on the optimisation level you've set, the calling convention of the function, whether it's an externally callable function and even whether you're running in Debug or Release mode so you really can't rely on this sort of level of detail. In this case because CoInitialzeEx is a precompiled DLL function the way its called will at least be consistent all the time, will very likely follow the 'C' calling convention (lookup __cdecl in MSDN) and all parameters will probably be passed on the Stack. As for the assembly code itself I'm terrible at Intel assembler and really couldn't help you with trying to disentangle it.

"The secret of happiness is freedom, and the secret of freedom, courage."
Thucydides (B.C. 460-400)

George_George15-Jul-08 22:26

15-Jul-08 22:26

Thanks Matthew,

So your suggestion is to look at the assembly code?

I have diassembled and posted here the beginning part of function CoInitializeEx, how from the assembly code do you know are the input parameters (e.g. in which memory address or in which registers)?

Sorry the assembly code is long, and I think posting the beginning part is fine?

0:000> uf ole32!CoInitializeEx
 000007ff`571e2e50 488bc4          mov     rax,rsp
 000007ff`571e2e53 4881ec08010000  sub     rsp,108h
 000007ff`571e2e5a 48895808        mov     qword ptr [rax+8],rbx
 000007ff`571e2e5e 4c8960f8        mov     qword ptr [rax-8],r12
 000007ff`571e2e62 4c8968f0        mov     qword ptr [rax-10h],r13
 000007ff`571e2e66 e9e1d20000      jmp     ole32!CoInitializeEx+0x16 (000007ff`571f014c)


 000007ff`571f014c 448be2          mov     r12d,edx
 000007ff`571f014f 488bd9          mov     rbx,rcx
 000007ff`571f0152 e87913faff      call    ole32!CoVrfDllMainCheck (000007ff`571914d0)
 000007ff`571f0157 90              nop
 000007ff`571f0158 e9b914faff      jmp     ole32!CoInitializeEx+0x21 (000007ff`57191616)


 000007ff`57191616 458bdc          mov     r11d,r12d
 000007ff`57191619 4183e30e        and     r11d,0Eh
 000007ff`5719161d 453bdc          cmp     r11d,r12d
 000007ff`57191620 0f8537eb0500    jne     ole32!CoInitializeEx+0x2d (000007ff`571f015d)

regards,
George

Matthew Faithfull16-Jul-08 6:46

Matthew Faithfull

16-Jul-08 6:46

Sorry George you need someone who can read 64bit Intel Assembly language. That's not me I'm afraid. It looks like rbx, r12 and r13 are being moved into memory relative to rax. My guess would be that's the parameters being copied but I wouldn't swear to it and I don't even know what rbx,r12,r13 or rax actually are.

"The secret of happiness is freedom, and the secret of freedom, courage."
Thucydides (B.C. 460-400)

George_George16-Jul-08 19:46

16-Jul-08 19:46

Thanks Matthew,

Do you have any books or documents to refer to read to learn x64 assembly? My current books/documents are only dealing with 32-bit or even 16-bit assembly language.

My issue happens only with 64-bit application. Any ideas or refers?

regards,
George

Mark Salsbery14-Jul-08 6:11

Mark Salsbery

14-Jul-08 6:11

You should be able to make a simple C++ project that makes one
call to CoInitializeEx. Bring up the disassembly debug window and step
through the asm code.

Mark

Mark Salsbery
Microsoft MVP - Visual C++
Java | [Coffee]

George_George14-Jul-08 16:16

14-Jul-08 16:16

Thanks Mark,

Here is my code and related assembly code. How do you know which register/memory is used as 1st and 2nd input parameter to CoInitializeEx?

0:000> kp
Child-SP          RetAddr           Call Site
00000000`0012ff18 00000001`4000100e ole32!CoInitializeEx(void * pMalloc = 0x00000034`00000008, unsigned long flags = 0x184) 
00000000`0012ff20 00000001`400011d2 TestCoInitializeEx1!main(void)+0xe
00000000`0012ff50 00000000`77d5964c TestCoInitializeEx1!__tmainCRTStartup(void)+0x11a
00000000`0012ff80 00000000`00000000 kernel32!BaseProcessStart(<function> * lpStartAddress = 0x00000001`40001320)+0x29

0:000> ub 00000001`4000100e
TestCoInitializeEx1!main <PERF> (TestCoInitializeEx1+0xff8):
00000001`40000ff8 0000            add     byte ptr [rax],al
TestCoInitializeEx1!main <PERF> (TestCoInitializeEx1+0xffa):
00000001`40000ffa 0000            add     byte ptr [rax],al
TestCoInitializeEx1!main <PERF> (TestCoInitializeEx1+0xffc):
00000001`40000ffc 0000            add     byte ptr [rax],al
TestCoInitializeEx1!main <PERF> (TestCoInitializeEx1+0xffe):
00000001`40000ffe 0000            add     byte ptr [rax],al
TestCoInitializeEx1!main [d:\visual studio 2008\projects\testcoinitializeex1\testcoinitializeex1\main.cpp @ 5]:
00000001`40001000 4883ec28        sub     rsp,28h
00000001`40001004 33d2            xor     edx,edx
00000001`40001006 33c9            xor     ecx,ecx
00000001`40001008 ff152a110000    call    qword ptr [TestCoInitializeEx1!_imp_CoInitializeEx (00000001`40002138)]

#include <windows.h>
#include <objbase.h>

int main()
{
	CoInitializeEx(NULL, 0);

	CoUninitialize();

	return 0;
}

regards,
George

Mark Salsbery15-Jul-08 5:25

Mark Salsbery

15-Jul-08 5:25

I'm not sure what you're looking for.

I don't see anything getting pushed on the stack or the actual call to
CoInitializeEx().

It looks like the edx and ecx registers are the parameters.

You may need to step into the _imp_CoInitializeEx call to see more.

This is 64-bit code?

Mark

Mark Salsbery
Microsoft MVP - Visual C++
Java | [Coffee]

George_George15-Jul-08 22:32