C / C++ / MFC

// The process code

#include <windows.h> 
#include <stdio.h> 
 
#define THREADCOUNT 1 
#define DLL_NAME    TEXT("testdll.dll")

VOID ErrorExit(LPSTR); 

typedef BOOL(*StoreDataFp)(DWORD);
typedef BOOL (*GetDataFp)(DWORD*);
 
DWORD WINAPI ThreadFunc(VOID) 
{   
   int i;

  HMODULE hMod;
  hMod  = LoadLibrary(TEXT("testdll.dll"));

  StoreDataFp StoreData = (StoreDataFp)GetProcAddress(hMod,TEXT("StoreData"));

  GetDataFp GetData = (GetDataFp)GetProcAddress(hMod, TEXT("GetData"));

   if(!StoreData(GetCurrentThreadId()))
      ErrorExit("StoreData error");

   for(i=0; i<5; i++)
   {
      DWORD dwOut;
      if(!GetData(&dwOut))
         ErrorExit("GetData error");
      if( dwOut != GetCurrentThreadId())
         printf("thread %d: data is incorrect (%d)\n", GetCurrentThreadId(), dwOut);
      else printf("thread %d: data is correct\n", GetCurrentThreadId());
      Sleep(0);
   }
   return 0; 
} 
 
int main(VOID) 
{ 
   DWORD IDThread; 
   HANDLE hThread[THREADCOUNT]; 
   int i; 
 
// Load the DLL

   LoadLibrary(DLL_NAME);
 
// Create multiple threads. 
 
   for (i = 0; i < THREADCOUNT; i++) 
   { 
      hThread[i] = CreateThread(NULL, // default security attributes 
         0,                           // use default stack size 
         (LPTHREAD_START_ROUTINE) ThreadFunc, // thread function 
         NULL,                    // no thread function argument 
         0,                       // use default creation flags 
         &IDThread);              // returns thread identifier 
 
   // Check the return value for success. 
      if (hThread[i] == NULL) 
         ErrorExit("CreateThread error\n"); 
   } 
 
   WaitForMultipleObjects(THREADCOUNT, hThread, TRUE, INFINITE); 
 
   return 0; 
} 
 
VOID ErrorExit (LPSTR lpszMessage) 
{ 
   fprintf(stderr, "%s\n", lpszMessage); 
   ExitProcess(0); 
}

// The DLL code

#include <windows.h>

static DWORD dwTlsIndex; // address of shared memory
 
// DllMain() is the entry-point function for this DLL. 
 
BOOL WINAPI DllMain(HINSTANCE hinstDLL,  // DLL module handle
    DWORD fdwReason,                     // reason called
    LPVOID lpvReserved)                  // reserved
{ 
    LPVOID lpvData; 
    BOOL fIgnore; 
 
    switch (fdwReason) 
    { 
        // The DLL is loading due to process 
        // initialization or a call to LoadLibrary. 
 
        case DLL_PROCESS_ATTACH: 
 
            // Allocate a TLS index.
 
            if ((dwTlsIndex = TlsAlloc()) == TLS_OUT_OF_INDEXES) 
                return FALSE; 
 
            // No break: Initialize the index for first thread.
 
        // The attached process creates a new thread. 
 
        case DLL_THREAD_ATTACH: 
 
            // Initialize the TLS index for this thread.
 
            lpvData = (LPVOID) LocalAlloc(LPTR, 256); 
            if (lpvData != NULL) 
                fIgnore = TlsSetValue(dwTlsIndex, lpvData); 
 
            break; 
 
        // The thread of the attached process terminates.
 
        case DLL_THREAD_DETACH: 
 
            // Release the allocated memory for this thread.
 
            lpvData = TlsGetValue(dwTlsIndex); 
            if (lpvData != NULL) 
                LocalFree((HLOCAL) lpvData); 
 
            break; 
 
        // DLL unload due to process termination or FreeLibrary. 
 
        case DLL_PROCESS_DETACH: 
 
            // Release the allocated memory for this thread.
 
            lpvData = TlsGetValue(dwTlsIndex); 
            if (lpvData != NULL) 
                LocalFree((HLOCAL) lpvData); 
 
            // Release the TLS index.
 
            TlsFree(dwTlsIndex); 
            break; 
 
        default: 
            break; 
    } 
 
    return TRUE; 
    UNREFERENCED_PARAMETER(hinstDLL); 
    UNREFERENCED_PARAMETER(lpvReserved); 
}

extern "C" __declspec(dllexport)BOOL WINAPI StoreData(DWORD dw)
{
   LPVOID lpvData; 
   DWORD * pData;  // The stored memory pointer 


   // Retrieve a data pointer for the current thread
   lpvData = TlsGetValue(dwTlsIndex); 

   // If NULL, allocate memory for the TLS slot for this thread
   if (lpvData == NULL)
   {
      lpvData = (LPVOID) LocalAlloc(LPTR, 256); 
      if (lpvData == NULL) 
         return FALSE;
      if (!TlsSetValue(dwTlsIndex, lpvData))
         return FALSE;
   }

   pData = (DWORD *) lpvData; // Cast to my data type.
   // In this example, it is only a pointer to a DWORD
   // but it can be a structure pointer to contain more complicated data.

   (*pData) = dw;
   return TRUE;
}

extern "C" __declspec(dllexport) BOOL WINAPI GetData(DWORD *pdw)
{
   LPVOID lpvData; 
   DWORD * pData;  // The stored memory pointer 

   lpvData = TlsGetValue(dwTlsIndex); 
   if (lpvData == NULL)
      return FALSE;

   pData = (DWORD *) lpvData;
   (*pdw) = (*pData);
   return TRUE;
}

<code>/************************************************************************/
/* create the window and the splitters                                  */
/************************************************************************/
BOOL CMainFrame::OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext) 
{

	CRect spRect;
	CRect cr; 
	GetClientRect(&cr);
	GetClientRect(&spRect);
//------- Create main_splitter ----------
	m_Splitter_Main.CreateStatic(this, 4, 1); 

	m_Splitter_Main.SetRowInfo(0, spRect.Height()/4, 0);
	m_Splitter_Main.SetRowInfo(1, spRect.Height()/4, 0);
	m_Splitter_Main.SetRowInfo(2, spRect.Height()/4, 0);
	m_Splitter_Main.SetRowInfo(3, spRect.Height()/4, 0);

 	m_Splitter_Main.CreateView(1, 0, RUNTIME_CLASS(CTest_01View), CSize(0, cr.Height()/4), pContext); 
	m_Splitter_Main.CreateView(2, 0, RUNTIME_CLASS(CTest_01View), CSize(0, cr.Height()/4), pContext); 


	m_Splitter_Child_1.CreateStatic(&m_Splitter_Main, 1, 3, WS_CHILD | WS_VISIBLE, m_Splitter_Main.IdFromRowCol(0, 0)); 
	m_Splitter_Child_1.CreateView(0, 0, RUNTIME_CLASS(CTest_01View), CSize(cr.Width()/3, 0), pContext); 
	m_Splitter_Child_1.CreateView(0, 1, RUNTIME_CLASS(CTest_01View), CSize(cr.Width()/3, 0), pContext); 
	m_Splitter_Child_1.CreateView(0, 2, RUNTIME_CLASS(CTest_01View), CSize(cr.Width()/3, 0), pContext);

 	m_Splitter_Child_2.CreateStatic(&m_Splitter_Main, 1, 2, WS_CHILD | WS_VISIBLE, m_Splitter_Main.IdFromRowCol(3, 0)); 
 	m_Splitter_Child_2.CreateView(0, 0, RUNTIME_CLASS(CTest_01View), CSize(cr.Width()/2, 0), pContext);
	m_Splitter_Child_2.CreateView(0, 1, RUNTIME_CLASS(CTest_01View), CSize(cr.Width()/2, 0), pContext); 

	return TRUE;	
}

/************************************************************************/
/* resize the splitter                                                  */
/************************************************************************/
void CMainFrame::OnSize(UINT nType, int cx, int cy) 
{
	CFrameWnd::OnSize(nType, cx, cy);
	int iCur_cy, iMin_cy;
	iMin_cy = 0;
	CRect spRect;
	m_Splitter_Main.GetClientRect(spRect);

	if ((nType == SIZE_MAXIMIZED)||(m_Splitter_Main.IsWindowVisible() && nType == SIZE_RESTORED))
	{
		m_Splitter_Main.GetRowInfo(0 ,iCur_cy, iMin_cy);
	 	m_Splitter_Main.SetRowInfo(0, iCur_cy, 0);
	// 	m_Splitter_Main.SetRowInfo(1, spRect.Height()/4, 0);
	// 	m_Splitter_Main.SetRowInfo(2, spRect.Height()/4, 0);
	// 	m_Splitter_Main.SetRowInfo(3, spRect.Height()/4, 0);
		
		m_Splitter_Main.RecalcLayout();	
	}	


}
</code>

#include <iostream>

using namespace std;

int foo (int a)
{
	int b;
	cin >> b;
	a = a * b;

	return a;
}

int main()
{
0000000140001000  sub         rsp,28h 
// ebp is not used?
	cout << foo (10);
0000000140001004  mov         rcx,qword ptr [__imp_std::cin (140002080h)] 
000000014000100B  lea         rdx,[rsp+30h] 
// rcx as the 1st parameter for function operator >>
// what is the purpose of rdx here, store the 2nd parameter to operator >>, which is address of b (address of an integer)?
0000000140001010  call        qword ptr [__imp_std::basic_istream<char,std::char_traits<char> >::operator>> (140002078h)] 
0000000140001016  mov         r11d,dword ptr [rsp+30h] 
000000014000101B  mov         rcx,qword ptr [__imp_std::cout (140002090h)] 
0000000140001022  lea         edx,[r11+r11*4] 
0000000140001026  add         edx,edx 
0000000140001028  call        qword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (140002088h)] 
	return 0;
000000014000102E  xor         eax,eax 
}