Attachment #139720 for bug #194081

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 11-16 Link Here

(-)src-native/src/BaseProf/ProfEnv.cpp (-19 / +591 lines)
11	*	11	*
12	* $Id: ProfEnv.cpp,v 1.31 2008/12/08 13:37:37 jkubasta Exp $	12	* $Id: ProfEnv.cpp,v 1.31 2008/12/08 13:37:37 jkubasta Exp $
13	************************************************************************/	13	************************************************************************/
		14	#ifndef LIN
		15	#pragma warning(disable:4786) // Add for bug 194081 to disable VC compiler warning when use STL
		16	#endif
14		17
15	#include "ProfEnv.h"	18	#include "ProfEnv.h"
16	#include "log.h"	19	#include "log.h"
Lines 19-24 Link Here
19	using namespace Martini::MPI;	22	using namespace Martini::MPI;
20	using namespace Martini::OSA;	23	using namespace Martini::OSA;
21	using namespace Martini::JPIAgent;	24	using namespace Martini::JPIAgent;
		25	using namespace std; // Add for bug 194081
22		26
23	CProfEnv::CProfEnv(){	27	CProfEnv::CProfEnv(){
24	m_pClassSData = 0;	28	m_pClassSData = 0;
Lines 61-66 Link Here
61	m_pAggStorage->Destroy();	65	m_pAggStorage->Destroy();
62	m_pSSMethodLeaveData_LockObject->Destroy();	66	m_pSSMethodLeaveData_LockObject->Destroy();
63	lockGetThreadInfoObject->Destroy();	67	lockGetThreadInfoObject->Destroy();
		68
		69	// Add for bug 194081
		70	m_pShadowStackTracker = NULL;
		71	// Add for bug 194081
64	}	72	}
65		73
66	void	74	void
Lines 101-106 Link Here
101	delete m_pMethodSData;	109	delete m_pMethodSData;
102	}	110	}
103	m_pMethodSDataLockObject->Leave();	111	m_pMethodSDataLockObject->Leave();
		112
		113	// Add for bug 194081
		114	if (m_pShadowStackTracker)
		115	{
		116	delete m_pShadowStackTracker;
		117	m_pShadowStackTracker = NULL;
		118	}
		119	// Add for bug 194081
104	}	120	}
105		121
106	/*	122	/*
Lines 124-129 Link Here
124	}	140	}
125	libraryLoader->Destroy();	141	libraryLoader->Destroy();
126	(*ecpEnv)(profName, &ec_env);	142	(*ecpEnv)(profName, &ec_env);
		143
		144	// Add for bug 194081
		145	m_pShadowStackTracker = new CCGShadowStackTracker(*this);
		146	if ( (NULL == m_pShadowStackTracker) \|\|
		147	!(m_pShadowStackTracker->ValidateCGShadowStackTracker()) )
		148	{
		149	return MRTE_ERROR_FAIL;
		150	}
		151	// Add for bug 194081
		152
127	return MRTE_RESULT_OSA_PLACE_HOLDER;	153	return MRTE_RESULT_OSA_PLACE_HOLDER;
128	}	154	}
129		155
Lines 209-214 Link Here
209	return ret;	235	return ret;
210	}	236	}
211		237
		238	// Add for bug 194081
		239	void
		240	CProfEnv::DeleteMethodsData()
		241	{
		242	if (m_pMethodSData)
		243	{
		244	delete m_pMethodSData;
		245	m_pMethodSData = NULL;
		246	}
		247	}
		248	// Add for bug 194081
		249
212	void	250	void
213	CProfEnv::AddNewMethodData(SMethodInfo* pSMethodInfo, TId methodId, bool isPrinted)	251	CProfEnv::AddNewMethodData(SMethodInfo* pSMethodInfo, TId methodId, bool isPrinted)
214	{	252	{
Lines 366-374 Link Here
366	lockObjectCheckObject->Leave();	404	lockObjectCheckObject->Leave();
367	}	405	}
368		406
		407	// Add for bug 194081. Filter additional data referring to CanInstrumentClass
		408	bool CProfEnv::IsExcludedClass(const char* szClassName)
		409	{
		410	static char* ExcludedClassPatterns[] =
		411	{
		412	"org.eclipse.tptp.martini.",
		413	"com.ibm.crypto",
		414	"sun.reflect.Generated",
		415	"jrockit.",
		416	"com.Intel.VTune.VTuneAPI",
		417	"org.eclipse.hyades.collection.profiler",
		418	"java.lang.",
		419	"java.security.",
		420	"java.awt.",
		421	"java.io.",
		422	"javax.swing."
		423	"com.ibm.jvm.",
		424	"com.ibm.misc.",
		425	"com.ibm.oti.",
		426	"sun.nio.",
		427	"CGLIB$$"
		428	};
		429
		430	// Check if the class appear in the excluded class patterns list
		431	unsigned int patternArraySize =
		432	sizeof(ExcludedClassPatterns)/sizeof(*ExcludedClassPatterns);
		433
		434	for (unsigned int i = 0; i < patternArraySize; ++i)
		435	{
		436	char *szExcludedPattern = ExcludedClassPatterns[i];
		437	if (strstr(szClassName, szExcludedPattern) != NULL)
		438	{
		439	return true;
		440	}
		441	}
		442
		443	return false;
		444	}
		445	// Add for bug 194081. Filter additional data referring to CanInstrumentClass
369		446
370	void	447	void
371	CProfEnv::CheckMethodId(TId methodId) {	448	CProfEnv::CheckMethodId(TId methodId) {
		449	// Add for bug 194081 to filter additional data after reattach
		450	SMethodInfo methodClassInfo = {0};
		451	TResult iRes = m_pMpiApi->GetMethodInfo(m_clientId,
		452	methodId, DR_CLASS_NAME, &methodClassInfo);
		453	LOG_ASSERT(iRes == MRTE_RESULT_OK);
		454	LOG_ASSERT((methodClassInfo.validData & DR_CLASS_NAME) != 0);
		455
		456	if (IsExcludedClass(methodClassInfo.szClassName))
		457	{
		458	return;
		459	}
		460	// Add for bug 194081 to filter additional data after reattach
		461
372	bool isPrint = false;	462	bool isPrint = false;
373		463
374	m_pMethodSDataLockObject->Enter();	464	m_pMethodSDataLockObject->Enter();
Lines 377-387 Link Here
377	return;	467	return;
378	}	468	}
379		469
380	SMethodInfo* methodInfo = new SMethodInfo();	470	SMethodInfo* methodInfo = new SMethodInfo();
		471	if (NULL == methodInfo)
		472	{
		473	m_pMethodSDataLockObject->Leave();
		474	return;
		475	}
		476
381	methodInfo->managedToSrcLineMap.uiSize = 1;	477	methodInfo->managedToSrcLineMap.uiSize = 1;
382	methodInfo->managedToSrcLineMap.entries = (SLineNumberTableEntry)malloc(sizeof(SLineNumberTableEntry) 1);	478	methodInfo->managedToSrcLineMap.entries = (SLineNumberTableEntry)malloc(sizeof(SLineNumberTableEntry) 1);
383		479
384	TResult iRes = m_pMpiApi->GetMethodInfo(m_clientId, methodId,	480	iRes = m_pMpiApi->GetMethodInfo(m_clientId, methodId,
385	DR_JAVA_NATIVE_METHOD_NAME \| DR_JAVA_NATIVE_METHOD_SIGNATURE \| DR_METHOD_NAME \| DR_METHOD_SIGNATURE \|	481	DR_JAVA_NATIVE_METHOD_NAME \| DR_JAVA_NATIVE_METHOD_SIGNATURE \| DR_METHOD_NAME \| DR_METHOD_SIGNATURE \|
386	DR_JAVA_NATIVE_CLASS_NAME \| DR_CLASS_NAME \| DR_METHOD_LINE_NUMBERS \| DR_CLASS_ID \| DR_MANAGED_TO_SRC_LINE_MAP, methodInfo);	482	DR_JAVA_NATIVE_CLASS_NAME \| DR_CLASS_NAME \| DR_METHOD_LINE_NUMBERS \| DR_CLASS_ID \| DR_MANAGED_TO_SRC_LINE_MAP, methodInfo);
387	if (iRes == MRTE_ERROR_BUFFER_TOO_SHORT) {	483	if (iRes == MRTE_ERROR_BUFFER_TOO_SHORT) {
Lines 536-543 Link Here
536	void	632	void
537	CProfEnv::GetStackTrace(TId threadId, SStackTrace_* stackTrace)	633	CProfEnv::GetStackTrace(TId threadId, SStackTrace_* stackTrace)
538	{	634	{
539	SThreadInfo threadInfo;	635	SThreadInfo threadInfo ={0};
540	threadInfo.vmOffsetStack.uiSize = 0;
541	int size = 0;	636	int size = 0;
542	int maxDepth = ec_env->getMaxStackDepth();	637	int maxDepth = ec_env->getMaxStackDepth();
543	TResult retVal;	638	TResult retVal;
Lines 569-610 Link Here
569	return;	664	return;
570	}	665	}
571	} while (retVal == MRTE_ERROR_BUFFER_TOO_SHORT);	666	} while (retVal == MRTE_ERROR_BUFFER_TOO_SHORT);
572	stackTrace->uiSize = threadInfo.vmOffsetStack.uiActualSize;	667
573	stackTrace->pStackEntries = (SStackEntry_)malloc(sizeof(SStackEntry_) stackTrace->uiSize);	668	ConvertStackTrace(&threadInfo, stackTrace);
574	for (unsigned int i = 0; i < stackTrace->uiSize; i++) {
575	stackTrace->pStackEntries[i].methodId = threadInfo.vmOffsetStack.pStackEntries[i].methodId;
576	SMethodInfo* methodInfo = GetMethodData(stackTrace->pStackEntries[i].methodId);
577	stackTrace->pStackEntries[i].methodName = (char*)malloc(strlen(methodInfo->szMethodName) + strlen(methodInfo->szMethodSig) + strlen(methodInfo->szClassName) + 3);
578	sprintf(stackTrace->pStackEntries[i].methodName, "%s.%s %s", methodInfo->szClassName, methodInfo->szMethodName, methodInfo->szMethodSig);
579	stackTrace->pStackEntries[i].lineNumber = GetLineNumber(threadInfo.vmOffsetStack.pStackEntries[i].location, &(methodInfo->managedToSrcLineMap));
580	}
581	free(threadInfo.vmOffsetStack.pStackEntries);	669	free(threadInfo.vmOffsetStack.pStackEntries);
582	}	670	}
583		671
584	void	672	void
585	CProfEnv::ConvertStackTrace(SThreadInfo* threadInfo, SStackTrace_* stackTrace)	673	CProfEnv::ConvertStackTrace(SThreadInfo* threadInfo, SStackTrace_* stackTrace)
586	{	674	{
		675	stackTrace->pStackEntries = (SStackEntry_)malloc(sizeof(SStackEntry_) threadInfo->vmOffsetStack.uiActualSize);
		676	if (NULL == stackTrace->pStackEntries)
		677	{
		678	stackTrace->uiSize = 0;
		679	stackTrace->pStackEntries = 0;
		680	return;
		681	}
		682
587	stackTrace->uiSize = threadInfo->vmOffsetStack.uiActualSize;	683	stackTrace->uiSize = threadInfo->vmOffsetStack.uiActualSize;
588	stackTrace->pStackEntries = (SStackEntry_)malloc(sizeof(SStackEntry_) stackTrace->uiSize);	684	memset(stackTrace->pStackEntries, 0, sizeof(SStackEntry_) * stackTrace->uiSize);
		685
589	for (unsigned int i = 0; i < stackTrace->uiSize; i++) {	686	for (unsigned int i = 0; i < stackTrace->uiSize; i++) {
590	stackTrace->pStackEntries[i].methodId = threadInfo->vmOffsetStack.pStackEntries[i].methodId;	687	stackTrace->pStackEntries[i].methodId = threadInfo->vmOffsetStack.pStackEntries[i].methodId;
591	SMethodInfo* methodInfo = GetMethodData(stackTrace->pStackEntries[i].methodId);	688	SMethodInfo* methodInfo = GetMethodData(stackTrace->pStackEntries[i].methodId);
592	stackTrace->pStackEntries[i].methodName = (char*)malloc(strlen(methodInfo->szMethodName) + strlen(methodInfo->szMethodSig) + strlen(methodInfo->szClassName) + 3);	689	if (NULL != methodInfo)
593	sprintf(stackTrace->pStackEntries[i].methodName, "%s.%s %s", methodInfo->szClassName, methodInfo->szMethodName, methodInfo->szMethodSig);	690	{
594	stackTrace->pStackEntries[i].lineNumber = GetLineNumber(threadInfo->vmOffsetStack.pStackEntries[i].location, &(methodInfo->managedToSrcLineMap));	691	stackTrace->pStackEntries[i].methodName =
		692	(char*)malloc(strlen(methodInfo->szMethodName) +
		693	strlen(methodInfo->szMethodSig) +
		694	strlen(methodInfo->szClassName) + 3); // +3 for two separators '.' and ' ', and for end of string
		695
		696	if (NULL != stackTrace->pStackEntries[i].methodName)
		697	{
		698	sprintf(stackTrace->pStackEntries[i].methodName, "%s.%s %s",
		699	methodInfo->szClassName, methodInfo->szMethodName, methodInfo->szMethodSig);
		700	}
		701
		702	stackTrace->pStackEntries[i].lineNumber =
		703	GetLineNumber(threadInfo->vmOffsetStack.pStackEntries[i].location,
		704	&(methodInfo->managedToSrcLineMap));
		705	}
595	}	706	}
596	}	707	}
597		708
598	void	709	void
599	CProfEnv::FreeStackTrace(SStackTrace_* stackTrace)	710	CProfEnv::FreeStackTrace(SStackTrace_* stackTrace)
600	{	711	{
601	if (stackTrace->pStackEntries == 0) {	712	if (NULL == stackTrace \|\| stackTrace->pStackEntries == NULL) {
602	return;	713	return;
603	}	714	}
604	for (unsigned int i = 0; i < stackTrace->uiSize; i++) {	715	for (unsigned int i = 0; i < stackTrace->uiSize; i++) {
605	free(stackTrace->pStackEntries[i].methodName);	716	if (NULL != stackTrace->pStackEntries[i].methodName)
		717	{
		718	free(stackTrace->pStackEntries[i].methodName);
		719	stackTrace->pStackEntries[i].methodName = NULL;
		720	}
606	}	721	}
607	free(stackTrace->pStackEntries);	722	free(stackTrace->pStackEntries);
		723	stackTrace->pStackEntries = NULL;
		724	stackTrace->uiSize = 0;
608	}	725	}
609		726
610	//==================================================================================	727	//==================================================================================
Lines 791-793 Link Here
791	return MRTE_RESULT_OK;	908	return MRTE_RESULT_OK;
792	}	909	}
793		910
		911	//==================================================================
		912	// Add for bug 194081
		913	CCGShadowStackTracker::CCGShadowStackTracker(CProfEnv& profEnv)
		914	: m_refProfEnv(profEnv)
		915	{
		916	m_lockVMStackDataMap = CreateThreadSync();
		917	}
		918
		919	CCGShadowStackTracker::~CCGShadowStackTracker()
		920	{
		921	if (m_lockVMStackDataMap)
		922	{
		923	m_lockVMStackDataMap->Destroy();
		924	}
		925	}
		926
		927	bool CCGShadowStackTracker::isNeedTrack()
		928	{
		929	return (
		930	((m_refProfEnv.ec_env)->isCGExecDetails()) &&
		931	!((m_refProfEnv.ec_env)->isStandAlone())
		932	);
		933	}
		934
		935	bool CCGShadowStackTracker::ValidateCGShadowStackTracker()
		936	{
		937	if (!isNeedTrack())
		938	{
		939	return true;
		940	}
		941
		942	// You can add additional validate condition in this function
		943	return (NULL != m_lockVMStackDataMap);
		944	}
		945
		946	void CCGShadowStackTracker::TrackVMShutdown()
		947	{
		948	if (!(m_refProfEnv.IsSupportedEG(EG_CALL_GRAPH)))
		949	{// For profilers' common events, just handle for call graph
		950	return;
		951	}
		952
		953	if (!isNeedTrack())
		954	{
		955	return;
		956	}
		957
		958	ReportLeftStackTrackDataMethodsLeave();
		959	}
		960
		961	TResult CCGShadowStackTracker::InitNewThreadInfoArray(
		962	SThreadInfoArray& threadInfoArray,
		963	int MAX_THREADS, int MAX_FRAMES)
		964	{
		965	DestroyThreadInfoArray(threadInfoArray);
		966
		967	threadInfoArray.pEntries =
		968	(SThreadInfoArrayEntry)malloc(sizeof(SThreadInfoArrayEntry) MAX_THREADS);
		969	if (NULL == threadInfoArray.pEntries)
		970	{
		971	return MRTE_ERROR_OUT_OF_MEMORY;
		972	}
		973
		974	threadInfoArray.uiSize = MAX_THREADS;
975	memset(threadInfoArray.pEntries, 0, sizeof(SThreadInfoArrayEntry) * MAX_THREADS);
976
977	unsigned int i = 0;
978	for (i = 0; i < MAX_THREADS; i++)
979	{
980	threadInfoArray.pEntries[i].threadInfo.vmOffsetStack.uiSize = MAX_FRAMES;
981	threadInfoArray.pEntries[i].threadInfo.vmOffsetStack.pStackEntries = new SStackEntry[MAX_FRAMES];
982
983	if (NULL == threadInfoArray.pEntries[i].threadInfo.vmOffsetStack.pStackEntries)
984	{
985	DestroyThreadInfoArray(threadInfoArray);
986	return MRTE_ERROR_OUT_OF_MEMORY;
987	}
988
989	memset(threadInfoArray.pEntries[i].threadInfo.vmOffsetStack.pStackEntries, 0,
990	sizeof(SStackEntry) * MAX_FRAMES);
991	}
992
993	return MRTE_RESULT_OK;
994	}
995
996	void CCGShadowStackTracker::DestroyThreadInfoArray(
997	SThreadInfoArray& threadInfoArray)
998	{
999	if (NULL != threadInfoArray.pEntries)
1000	{
1001	for (unsigned int i = 0; i < threadInfoArray.uiSize; i++)
1002	{
1003	if (NULL != threadInfoArray.pEntries[i].threadInfo.vmOffsetStack.pStackEntries)
1004	{
1005	delete [](threadInfoArray.pEntries[i].threadInfo.vmOffsetStack.pStackEntries);
1006	}
1007	}
1008
1009	free(threadInfoArray.pEntries);
1010	}
1011
1012	threadInfoArray.uiSize = 0;
1013	threadInfoArray.uiActualSize = 0;
1014	}
1015
1016	TResult CCGShadowStackTracker::GetInitialShadowStackTraces(
1017	SThreadInfoArray& threadInfoArray)
1018	{
1019	// Suspend all VM threads and Get all threads stack traces
1020	TResult res = (m_refProfEnv.m_pMpiApi)->SuspendVM();
1021	if (MRTE_FAILED(res))
1022	{
1023	LOG_ERROR("Can not suspend VM when try to get shadow stack sanpshot")
1024	return res;
1025	}
1026
1027	// TODO: This fixed thread num and frame num is a limit, referring to original AttachEvent.cpp
1028	int MAX_THREADS = 100;
1029	int MAX_FRAMES = 100;
1030
1031	res = InitNewThreadInfoArray(threadInfoArray, MAX_THREADS, MAX_FRAMES);
1032	if (MRTE_FAILED(res))
1033	{
1034	(m_refProfEnv.m_pMpiApi)->ResumeVM();
1035	return res;
1036	}
1037
1038	res = (m_refProfEnv.m_pMpiApi)->GetAllThreadsInfo(m_refProfEnv.m_clientId, MAX_FRAMES,
1039	DR_VM_RELATIVE_STACK_TRACE, &threadInfoArray);
1040	if (MRTE_FAILED(res))
1041	{
1042	(m_refProfEnv.m_pMpiApi)->ResumeVM();
1043	DestroyThreadInfoArray(threadInfoArray);
1044	}
1045
1046	return res;
1047	}
1048
1049	void CCGShadowStackTracker::ReportThreadsStart(SThreadInfoArray& threadInfoArray)
1050	{
1051	for (unsigned int threadIdx = 0; threadIdx < threadInfoArray.uiActualSize; threadIdx++)
1052	{
1053	SThreadInfoArrayEntry* pThread = &(threadInfoArray.pEntries[threadIdx]);
1054
1055	// Clear outdated data
1056	m_refProfEnv.m_Tickets.ReleaseTicket(pThread->threadId);
1057	m_refProfEnv.m_Tickets.DeleteThread(pThread->threadId);
1058
1059	// Add new data info
1060	m_refProfEnv.m_Tickets.AddNewThread(pThread->threadId);
1061
1062	m_refProfEnv.GetThreadInfo(m_refProfEnv.m_clientId, pThread->threadId,
1063	DR_THREAD_INFO \| DR_THREAD_ELAPSED_TIME \| DR_THREAD_CPU_TIME, &(pThread->threadInfo));
1064
1065	if (m_refProfEnv.m_profilerIsActive)
1066	{
1067	(m_refProfEnv.ec_env)->PrintThreadStartElement(pThread->threadId, 0,
1068	&(pThread->threadInfo));
1069	}
1070	else
1071	{
1072	m_refProfEnv.StoreThreadEvent(pThread->threadId, THREAD_START_EVENT,
1073	&(pThread->threadInfo), 0);
1074	}
1075	}
1076	}
1077
1078	void CCGShadowStackTracker::ReportMethodEnter(TId threadId, SThreadInfo* pThreadInfo, TId methodId)
1079	{
1080	// Get classId according to methodId
1081	SMethodInfo methodInfo = {0};
1082	TResult iRes = (m_refProfEnv.m_pMpiApi)->GetMethodInfo(m_refProfEnv.m_clientId,
1083	methodId, DR_CLASS_ID \| DR_CLASS_NAME, &methodInfo);
1084	LOG_ASSERT(iRes == MRTE_RESULT_OK);
1085	LOG_ASSERT((methodInfo.validData & DR_CLASS_ID) != 0);
1086	LOG_ASSERT((methodInfo.validData & DR_CLASS_NAME) != 0);
1087
1088	if (m_refProfEnv.IsExcludedClass(methodInfo.szClassName))
1089	{
1090	return;
1091	}
1092
1093	// Just for Exec Details
1094	m_refProfEnv.CheckMethodId(methodId);
1095
1096	if (m_refProfEnv.m_profilerIsActive)
1097	{// Profiler is in run mode
1098	unsigned long ticket = m_refProfEnv.m_Tickets.GetNewTicket(threadId,
1099	pThreadInfo->uiCpuNanos, true);
1100	unsigned long stackDepth = m_refProfEnv.m_Tickets.GetStackDepth(threadId);
1101	(m_refProfEnv.ec_env)->PrintMethodEntryElement(threadId, methodId,
1102	methodInfo.classId, ticket, stackDepth);
1103	}
1104	else
1105	{// Profiler is in pause mode
1106	m_refProfEnv.m_Tickets.AddMethodEnterData(threadId, methodId,
1107	methodInfo.classId, pThreadInfo->uiCpuNanos);
1108	}
1109	}
1110
1111	void CCGShadowStackTracker::ReportMethodsEnter(SThreadInfoArray& threadInfoArray)
1112	{
1113	for (unsigned int threadIdx = 0; threadIdx < threadInfoArray.uiActualSize; threadIdx++)
1114	{
1115	TId threadId = threadInfoArray.pEntries[threadIdx].threadId;
1116	SThreadInfo* pThreadInfo = &(threadInfoArray.pEntries[threadIdx].threadInfo);
1117
1118	for (int stackTraceIdx = (pThreadInfo->vmOffsetStack).uiActualSize - 1; stackTraceIdx >= 0 ;
1119	stackTraceIdx--)
1120	{
1121	// Get methodId from stack trace info
1122	SStackEntry* pStackEntry = &(pThreadInfo->vmOffsetStack.pStackEntries[stackTraceIdx]);
1123
1124	ReportMethodEnter(threadId, pThreadInfo, pStackEntry->methodId);
1125	}
1126	}
1127	}
1128
1129	void CCGShadowStackTracker::SaveAllShadowStacksMethods(SThreadInfoArray& threadInfoArray)
1130	{
1131	for (unsigned int threadIdx = 0; threadIdx < threadInfoArray.uiActualSize; threadIdx++)
1132	{
1133	SThreadInfoArrayEntry* pThread = &(threadInfoArray.pEntries[threadIdx]);
1134	CVMStackTrackData vmStacks;
1135	vmStacks.threadId = pThread->threadId;
1136	unsigned int stackTraceSize =
1137	(pThread->threadInfo).vmOffsetStack.uiActualSize;
1138
1139	for (int stackTraceIdx = stackTraceSize - 1; stackTraceIdx >= 0; stackTraceIdx--)
1140	{
1141	vmStacks.shadowStack.push(
1142	(pThread->threadInfo).vmOffsetStack.pStackEntries[stackTraceIdx].methodId);
1143	}
1144
1145	m_VMStacktraceDataMap.insert(
1146	std::pair<MPI::TId, CVMStackTrackData>(vmStacks.threadId, vmStacks));
1147	}
1148	}
1149
1150	void CCGShadowStackTracker::TrackECAttach()
1151	{
1152	if (!(m_refProfEnv.IsSupportedEG(EG_CALL_GRAPH)))
1153	{// For profilers' common events, just handle for call graph
1154	return;
1155	}
1156
1157	if (!isNeedTrack())
1158	{
1159	return;
1160	}
1161
1162	SThreadInfoArray threadInfoArray = {0};
1163	TResult res = GetInitialShadowStackTraces(threadInfoArray);
1164	if (MRTE_FAILED(res))
1165	{
1166	LOG_ERROR("Can not get VM thread stack traces info.")
1167	return;
1168	}
1169
1170	// Report related events and get initial shadow stacks
1171	ReportThreadsStart(threadInfoArray);
1172
1173	ReportMethodsEnter(threadInfoArray);
1174
1175	SaveAllShadowStacksMethods(threadInfoArray);
1176
1177	DestroyThreadInfoArray(threadInfoArray);
1178	(m_refProfEnv.m_pMpiApi)->ResumeVM();
1179	}
1180
1181	void CCGShadowStackTracker::TrackECDetach()
1182	{
1183	if (!(m_refProfEnv.IsSupportedEG(EG_CALL_GRAPH)))
1184	{// For profilers' common events, just handle for call graph
1185	return;
1186	}
1187
1188	if (!isNeedTrack())
1189	{
1190	return;
1191	}
1192
1193	ReportLeftStackTrackDataMethodsLeave();
1194	}
1195
1196	void CCGShadowStackTracker::ReportMethodLeave(TId threadId, TId methodId,
1197	TTimeStamp uiCpuNanos)
1198	{
1199	SMethodInfo methodInfo;
1200	TResult iRes = (m_refProfEnv.m_pMpiApi)->GetMethodInfo(m_refProfEnv.m_clientId,
1201	methodId, DR_CLASS_ID \| DR_CLASS_NAME, &methodInfo);
1202	LOG_ASSERT(iRes == MRTE_RESULT_OK);
1203	LOG_ASSERT((methodInfo.validData & DR_CLASS_ID) != 0);
1204	LOG_ASSERT((methodInfo.validData & DR_CLASS_NAME) != 0);
1205
1206	if (m_refProfEnv.IsExcludedClass(methodInfo.szClassName))
1207	{
1208	return;
1209	}
1210
1211	// Just for Exec Details
1212	U64 cpuTime = uiCpuNanos - m_refProfEnv.m_Tickets.GetCpuTime(threadId);
1213	unsigned long ticket = m_refProfEnv.m_Tickets.ReleaseTicket(threadId);
1214
1215	if (m_refProfEnv.m_profilerIsActive)
1216	{
1217	(m_refProfEnv.ec_env)->PrintMethodExitElement(threadId, methodId,
1218	methodInfo.classId, ticket, cpuTime);
1219	}
1220	else if (ticket != -1)
1221	{
1222	m_refProfEnv.AddMethodLeaveData(threadId, methodId, methodInfo.classId,
1223	ticket, cpuTime);
1224	}
1225	}
1226
1227	void CCGShadowStackTracker::UpdateShadowStack(stack< TId >& tmpShadowStack,
1228	stack< TId >& shadowStack, const SMethodEnterEventData& data)
1229	{
1230	// Because normal stack is empty now, the tmpShadowStack must less or equal shadowStack
1231	while (tmpShadowStack.size() < shadowStack.size())
1232	{// Geneate method leave events for shadow stack method
1233	TId methodId = shadowStack.top();
1234	shadowStack.pop();
1235	ReportMethodLeave(data.threadId, methodId, data.uiCpuNanos);
1236	}
1237	}
1238
1239	void CCGShadowStackTracker::TrackMethodEnter(SMethodEnterEventData &data)
1240	{
1241	if (!isNeedTrack())
1242	{
1243	return;
1244	}
1245
1246	m_lockVMStackDataMap->Enter();
1247	map< MPI::TId, CVMStackTrackData >::iterator pos = m_VMStacktraceDataMap.find(data.threadId);
1248
1249	if (pos == m_VMStacktraceDataMap.end())
1250	{// Enter a new thread after attach, it has no shadow stack record and can be handled normally
1251	m_lockVMStackDataMap->Leave();
1252	return;
1253	}
1254
1255	CVMStackTrackData& refVmStacks = pos->second;
1256
1257	if (refVmStacks.normalStack.empty())
1258	{
1259	SStackTrace_ stackTrace = {0};
1260
1261	m_refProfEnv.GetStackTrace(data.threadId, &stackTrace);
1262
1263	std::stack< MPI::TId > tmpShadowStack;
1264	// Ignore the new entered method, CGProxy.EarlyMethodEnter and CGProxy.MethodEnter on the stack top
1265	const int ignoredMethodNum = 3;
1266	for (int stackTraceIdx = stackTrace.uiSize - 1; stackTraceIdx > ignoredMethodNum - 1; stackTraceIdx--)
1267	{
1268	tmpShadowStack.push(stackTrace.pStackEntries[stackTraceIdx].methodId);
1269	}
1270
1271	UpdateShadowStack(tmpShadowStack, refVmStacks.shadowStack, data);
1272
1273	m_refProfEnv.FreeStackTrace(&stackTrace);
1274	}
1275
1276	refVmStacks.normalStack.push(data.methodId);
1277	m_lockVMStackDataMap->Leave();
1278	}
1279
1280	// return value: If continue to handle the MethodLeave events
1281	bool CCGShadowStackTracker::TrackMethodLeave(SMethodLeaveEventData &data)
1282	{
1283	if (!isNeedTrack())
1284	{
1285	return true;
1286	}
1287
1288	m_lockVMStackDataMap->Enter();
1289	map< MPI::TId, CVMStackTrackData >::iterator pos = m_VMStacktraceDataMap.find(data.threadId);
1290
1291	if (pos == m_VMStacktraceDataMap.end())
1292	{// Enter a new thread after attach, it has no shadow stack record and can be handled normally
1293	m_lockVMStackDataMap->Leave();
1294	return true;
1295	}
1296
1297	CVMStackTrackData& refVmStacks = pos->second;
1298
1299	if (refVmStacks.normalStack.empty())
1300	{// Method leave notification is generated by instrumet before reattach, ignore it
1301	m_lockVMStackDataMap->Leave();
1302	return false;
1303	}
1304	else
1305	{
1306	refVmStacks.normalStack.pop();
1307	m_lockVMStackDataMap->Leave();
1308	return true;
1309	}
1310	}
1311
1312	void CCGShadowStackTracker::TrackThreadEnd(SThreadEventData &data)
1313	{
1314	if (!isNeedTrack())
1315	{
1316	return;
1317	}
1318
1319	m_lockVMStackDataMap->Enter();
1320	map< MPI::TId, CVMStackTrackData >::iterator pos = m_VMStacktraceDataMap.find(data.threadId);
1321
1322	if (pos == m_VMStacktraceDataMap.end())
1323	{// Enter a new thread after attach, it has no shadow stack record and can be handled normally
1324	m_lockVMStackDataMap->Leave();
1325	return;
1326	}
1327
1328	CVMStackTrackData& refVmStacks = pos->second;
1329
1330	// refVmStacks.shadowStack report method leave events
1331	while (!refVmStacks.shadowStack.empty())
1332	{
1333	TId methodId = refVmStacks.shadowStack.top();
1334	refVmStacks.shadowStack.pop();
1335	ReportMethodLeave(data.threadId, methodId, m_refProfEnv.m_Tickets.GetCpuTime(data.threadId));
1336	}
1337	m_lockVMStackDataMap->Leave();
1338	}
1339
1340	void CCGShadowStackTracker::ReportLeftStackTrackDataMethodsLeave()
1341	{
1342	m_lockVMStackDataMap->Enter();
1343
1344	map< MPI::TId, CVMStackTrackData >::iterator pos = m_VMStacktraceDataMap.begin();
1345	for(; pos != m_VMStacktraceDataMap.end(); pos++)
1346	{
1347	CVMStackTrackData& refVmStacks = pos->second;
1348
1349	while (!refVmStacks.normalStack.empty())
1350	{
1351	TId methodId = refVmStacks.normalStack.top();
1352	refVmStacks.normalStack.pop();
1353	ReportMethodLeave(pos->first, methodId, m_refProfEnv.m_Tickets.GetCpuTime(pos->first));
1354	}
1355
1356	while (!refVmStacks.shadowStack.empty())
1357	{
1358	TId methodId = refVmStacks.shadowStack.top();
1359	refVmStacks.shadowStack.pop();
1360	ReportMethodLeave(pos->first, methodId, m_refProfEnv.m_Tickets.GetCpuTime(pos->first));
1361	}
1362	}
1363	m_lockVMStackDataMap->Leave();
1364	}
1365	// Add for bug 194081

Lines 40-46 Link Here

(-)src-native/src/BaseProf/DetachEvent.cpp (-1 / +4 lines)
40	if (!m_pProfEnv->m_bVMInitDone) {	40	if (!m_pProfEnv->m_bVMInitDone) {
41	return;	41	return;
42	}	42	}
43	m_pProfEnv->ec_env->SetProfileOption("EXECDETAILS", "false");	43	// Modify for bug 194081
		44	// m_pProfEnv->ec_env->SetProfileOption("EXECDETAILS", "false");
		45	m_pProfEnv->m_pShadowStackTracker->TrackECDetach();
		46	// Modify for bug 194081
44	if (!m_pProfEnv->IsSupportedEG(EG_CALL_GRAPH) && !m_pProfEnv->IsSupportedEG(EG_HEAP)) {	47	if (!m_pProfEnv->IsSupportedEG(EG_CALL_GRAPH) && !m_pProfEnv->IsSupportedEG(EG_HEAP)) {
45	return;	48	return;
46	}	49	}

Lines 15-20 Link Here

(-)src-native/src/BaseProf/ProfEnv.h (+86 lines)
15	#ifndef _PROF_ENV_H_	15	#ifndef _PROF_ENV_H_
16	#define _PROF_ENV_H_	16	#define _PROF_ENV_H_
17		17
		18	// Add for bug 194081
		19	#include <stack>
		20	#include <map>
		21	// Add for bug 194081
		22
18	#include "MpiAPI.h"	23	#include "MpiAPI.h"
19	#include "OSA.h"	24	#include "OSA.h"
20		25
Lines 50-55 Link Here
50	MPI::SThreadInfo threadInfo; //For THREAD_START_EVENT only	55	MPI::SThreadInfo threadInfo; //For THREAD_START_EVENT only
51	MPI::TId objectId; //For THREAD_START_EVENT only	56	MPI::TId objectId; //For THREAD_START_EVENT only
52	};	57	};
		58
		59	// Add for bug 194081
		60	class CCGShadowStackTracker
		61	{
		62	class CVMStackTrackData
		63	{
		64	public:
		65	MPI::TId threadId;
		66	std::stack< MPI::TId > shadowStack;
		67	std::stack< MPI::TId > normalStack;
		68	};
		69
		70	public:
		71	CCGShadowStackTracker(CProfEnv& profEnv);
		72	~CCGShadowStackTracker();
		73
		74	// Assure init process is successful, called by CProfEnv init
		75	bool ValidateCGShadowStackTracker();
		76
		77	//---------------------------------------------------------------------
		78	// Common profiler events need to be tracked, except for VMInit, ECStart and ECStop event
		79	void TrackVMShutdown();
		80
		81	void TrackECAttach();
		82	void TrackECDetach();
		83
		84	//---------------------------------------------------------------------
		85	// Call Graph profiler specialized events, except for NewMethod and ThreadStart
		86	void TrackMethodEnter(MPI::SMethodEnterEventData& data);
		87
		88	// TrackMethodLeave return bool to avoid handle MethodLeave events before reattach
		89	bool TrackMethodLeave(MPI::SMethodLeaveEventData& data);
		90
		91	void TrackThreadEnd(MPI::SThreadEventData &data);
		92
		93	private:
		94	// Functions for deciding whether to track corresponding events
		95	bool isNeedTrack();
		96
		97	// Used by ECAttach tracker
		98	TResult InitNewThreadInfoArray(MPI::SThreadInfoArray& threadInfoArray,
		99	int MAX_THREADS, int MAX_FRAMES);
		100	void DestroyThreadInfoArray(MPI::SThreadInfoArray& threadInfoArray);
		101
		102	TResult GetInitialShadowStackTraces(MPI::SThreadInfoArray& threadInfoArray);
		103	void ReportThreadsStart(MPI::SThreadInfoArray& threadInfoArray); // Refer to CGProf ThreadStartHandler
		104
		105	void ReportMethodEnter(MPI::TId threadId, MPI::SThreadInfo* pThreadInfo, MPI::TId methodId);
		106	void ReportMethodsEnter(MPI::SThreadInfoArray& threadInfoArray);
		107
		108	void SaveAllShadowStacksMethods(MPI::SThreadInfoArray& threadInfoArray);
		109
		110	// Used by MethodEnter and ThreadEnd trackers, ReportLeftStackTrackDataMethodsLeave
		111	void ReportMethodLeave(MPI::TId threadId, MPI::TId methodId, MPI::TTimeStamp uiCpuNanos);
		112
		113	// Used by MethodEnter tracker
		114	void UpdateShadowStack(std::stack< MPI::TId >&, std::stack< MPI::TId >&,
		115	const MPI::SMethodEnterEventData&);
		116
		117	// Used by VMShutdown and Detach trackers
		118	// Generate method leave events for each left methods in track stack
		119	void ReportLeftStackTrackDataMethodsLeave();
		120
		121	private:
122	CProfEnv& m_refProfEnv;
123
124	OSA::IThreadSync* m_lockVMStackDataMap;
125	std::map< MPI::TId, CVMStackTrackData > m_VMStacktraceDataMap;
126	};
127	// Add for bug 194081
53		128
54	class CProfEnv	129	class CProfEnv
55	{	130	{
Lines 82-87 Link Here
82	bool IsObjectStored(MPI::TId objectId);	157	bool IsObjectStored(MPI::TId objectId);
83	//	158	//
84	// void AddNewMethodData(MPI::SMethodInfo* pSMethodInfo, MPI::TId methodId);	159	// void AddNewMethodData(MPI::SMethodInfo* pSMethodInfo, MPI::TId methodId);
		160	// Add for bug 194081
		161	void DeleteMethodsData();
		162	// Add for bug 194081
85	void AddNewMethodData(MPI::SMethodInfo* pSMethodInfo, MPI::TId methodId, bool isPrinted);	163	void AddNewMethodData(MPI::SMethodInfo* pSMethodInfo, MPI::TId methodId, bool isPrinted);
86	//	164	//
87	MPI::SMethodInfo* GetMethodData(MPI::TId methodId);	165	MPI::SMethodInfo* GetMethodData(MPI::TId methodId);
Lines 151-156 Link Here
151	MPI::TId m_clientId;	229	MPI::TId m_clientId;
152	// Profiler library name	230	// Profiler library name
153	char* profName;	231	char* profName;
		232
		233	// Add for bug 194081
		234	CCGShadowStackTracker* m_pShadowStackTracker;
		235
		236	// Filter some additional classes after reattach
		237	bool IsExcludedClass(const char* szClassName);
		238	// Add for bug 194081
		239
154	private:	240	private:
155	CClassDefDataSet* m_pClassSData;	241	CClassDefDataSet* m_pClassSData;
156	OSA::IThreadSync* m_pClassSDataLockObject;	242	OSA::IThreadSync* m_pClassSDataLockObject;

Lines 35-41 Link Here

(-)src-native/src/BaseProf/BaseProfiler.h (-1 / +1 lines)
35	// Constructor	35	// Constructor
36	CBaseProfiler();	36	CBaseProfiler();
37	// Destructor	37	// Destructor
38	~CBaseProfiler();	38	virtual ~CBaseProfiler();
39	// Initialization	39	// Initialization
40	TResult Init(MPI::IMpi pMpiApi, MPI::TId clientId, const char szOptions);	40	TResult Init(MPI::IMpi pMpiApi, MPI::TId clientId, const char szOptions);
41		41




    m_pProfEnv->DeleteAggCallGraphData();
    m_pProfEnv->DeleteStoredThreadEvents();

    // Add for bug 194081
    if (m_pProfEnv->ec_env->isCGExecDetails())
    {
        m_pProfEnv->DeleteMethodsData();
        m_pProfEnv->m_pShadowStackTracker->TrackECAttach();
    
        TResult res = m_pProfEnv->EnableSupportedEG();
        if (MRTE_FAILED(res))
        {
            if (MRTE_ERROR_PHASE_FAILURE == res) 
            {
                LOG_DIE("Attach failed (too early)");
            } 
            else
            {
                LOG_DIE("Attach failed");
            }
        }
        
        return;
    }
    // Add for bug 194081

    const int MAX_THREADS = 100;
    const int MAX_FRAMES = 100;
    TResult res; 


				if (m_pProfEnv->m_enableDataCollection) {
					if (m_pProfEnv->ec_env->isStackInfoNormal()) {
						SStackTrace_ stackTrace = {0};
						m_pProfEnv->ConvertStackTrace(&(threadInfoArray.pEntries[i].threadInfo), &stackTrace);
						m_pProfEnv->ec_env->PrintMonitorWaitElement(&data, &stackTrace);
						m_pProfEnv->FreeStackTrace(&stackTrace);

            }
        }
        for (i = 0; i < MAX_THREADS; i++) {
            delete [](threadInfoArray.pEntries[i].threadInfo.vmOffsetStack.pStackEntries);
        }
    } else {
        res = m_pProfEnv->m_pMpiApi->GetAllThreadsInfo(m_pProfEnv->m_clientId, 0, DR_THREAD_INFO, &threadInfoArray);




    if (!m_pProfEnv->m_profilerIsActive) {
        return;
    }
    // Modified for bug 194081
    if (m_pProfEnv->ec_env->isCGExecDetails())
    {
        m_pProfEnv->m_pShadowStackTracker->TrackVMShutdown();
    }
    else
    {
        m_pProfEnv->PrintAggCallGraph();
    }
    // Modified for bug 194081
    
    m_pProfEnv->ec_env->PrintRuntimeShutdownElement();
}

Lines 40-45 Link Here

(-)src-native/src/CGProf/ThreadEndEvent.cpp (+4 lines)
40	{	40	{
41	if ((data.validData & DR_THREAD_ID) != 0)	41	if ((data.validData & DR_THREAD_ID) != 0)
42	{	42	{
		43	// Add for bug 194081
		44	m_pProfEnv->m_pShadowStackTracker->TrackThreadEnd(data);
		45	// Add for bug 194081
		46
43	m_pProfEnv->m_Tickets.DeleteThread(data.threadId);	47	m_pProfEnv->m_Tickets.DeleteThread(data.threadId);
44	if (!m_pProfEnv->m_profilerIsActive) {	48	if (!m_pProfEnv->m_profilerIsActive) {
45	m_pProfEnv->StoreThreadEvent(data.threadId, THREAD_END_EVENT, &data, 0);	49	m_pProfEnv->StoreThreadEvent(data.threadId, THREAD_END_EVENT, &data, 0);

Lines 44-49 Link Here

(-)src-native/src/CGProf/MethodEnterEvent.cpp (+4 lines)
44	LOG_ASSERT((data.validData & DR_METHOD_ID) != 0);	44	LOG_ASSERT((data.validData & DR_METHOD_ID) != 0);
45	LOG_ASSERT((data.validData & DR_THREAD_ID) != 0);	45	LOG_ASSERT((data.validData & DR_THREAD_ID) != 0);
46	LOG_ASSERT((data.validData & DR_THREAD_CPU_TIME) != 0);	46	LOG_ASSERT((data.validData & DR_THREAD_CPU_TIME) != 0);
		47
		48	// Add for bug 194081
		49	m_pProfEnv->m_pShadowStackTracker->TrackMethodEnter(data);
		50	// Add for bug 194081
47		51
48	SMethodInfo classInfo;	52	SMethodInfo classInfo;
49	TResult iRes = m_pProfEnv->m_pMpiApi->GetMethodInfo(m_pProfEnv->m_clientId, data.methodId,	53	TResult iRes = m_pProfEnv->m_pMpiApi->GetMethodInfo(m_pProfEnv->m_clientId, data.methodId,

Lines 42-47 Link Here

(-)src-native/src/CGProf/MethodLeaveEvent.cpp (+8 lines)
42	LOG_ASSERT((data.validData & DR_METHOD_ID) != 0);	42	LOG_ASSERT((data.validData & DR_METHOD_ID) != 0);
43	LOG_ASSERT((data.validData & DR_THREAD_ID) != 0);	43	LOG_ASSERT((data.validData & DR_THREAD_ID) != 0);
44	LOG_ASSERT((data.validData & DR_THREAD_CPU_TIME) != 0);	44	LOG_ASSERT((data.validData & DR_THREAD_CPU_TIME) != 0);
		45
		46	// Add for bug 194081
		47	bool isContinueHandleMethodLeave = m_pProfEnv->m_pShadowStackTracker->TrackMethodLeave(data);
		48	if (!isContinueHandleMethodLeave)
		49	{
		50	return;
		51	}
		52	// Add for bug 194081
45		53
46	SMethodInfo classInfo;	54	SMethodInfo classInfo;
47	TResult iRes = m_pProfEnv->m_pMpiApi->GetMethodInfo(m_pProfEnv->m_clientId, data.methodId,	55	TResult iRes = m_pProfEnv->m_pMpiApi->GetMethodInfo(m_pProfEnv->m_clientId, data.methodId,

Lines 51-57 Link Here

(-)src-native/src/ThreadProf/ThreadInteractionEvent.cpp (-1 / +1 lines)
51	}	51	}
52		52
53	if (m_pProfEnv->ec_env->isStackInfoNormal()) {	53	if (m_pProfEnv->ec_env->isStackInfoNormal()) {
54	SStackTrace_ stackTrace;	54	SStackTrace_ stackTrace = {0};
55	m_pProfEnv->GetStackTrace(data.threadId, &stackTrace);	55	m_pProfEnv->GetStackTrace(data.threadId, &stackTrace);
56	m_pProfEnv->ec_env->printThreadInteractionElements(&data, &stackTrace);	56	m_pProfEnv->ec_env->printThreadInteractionElements(&data, &stackTrace);
57	m_pProfEnv->FreeStackTrace(&stackTrace);	57	m_pProfEnv->FreeStackTrace(&stackTrace);

Lines 95-101 Link Here

(-)src-native/src/JPIAgent/binformat.h (-1 / +8 lines)
95	}	95	}
96	size_t size = 0;	96	size_t size = 0;
97	for (size_t i = 0; i < length; ++i) {	97	for (size_t i = 0; i < length; ++i) {
98	size += strlen(t[i]) + 1;	98	if (NULL != t[i])
		99	{
		100	size += strlen(t[i]) + 1;
		101	}
		102	else
		103	{
		104	size += 1;
		105	}
99	}	106	}
100	return size;	107	return size;
101	}	108	}

Lines 144-150 Link Here

(-)src-native/src/JPIAgent/Options.h (-1 / +4 lines)
144		144
145	// is CG pfofiler aggregated	145	// is CG pfofiler aggregated
146	bool isCGExecDetails() {	146	bool isCGExecDetails() {
147	return (!isEnabled()) && (m_jvmtiAgent_Options.cgExecDetails == 1); //in enabled mode we support aggregated cg profiler only	147	// Modified for bug 194081
		148	//return (!isEnabled()) && (m_jvmtiAgent_Options.cgExecDetails == 1); //in enabled mode we support aggregated cg profiler only
		149	return (m_jvmtiAgent_Options.cgExecDetails == 1);
		150	// Modified for bug 194081
148	}	151	}
149		152
150	// if cg memory should be freed after snapshot then returns true	153	// if cg memory should be freed after snapshot then returns true

Return to bug 194081

Lines 45-50 Link Here

(-)src-native/src/BaseProf/AttachEvent.cpp (-2 / +25 lines)
45	m_pProfEnv->DeleteAggCallGraphData();	45	m_pProfEnv->DeleteAggCallGraphData();
46	m_pProfEnv->DeleteStoredThreadEvents();	46	m_pProfEnv->DeleteStoredThreadEvents();
47		47
		48	// Add for bug 194081
		49	if (m_pProfEnv->ec_env->isCGExecDetails())
		50	{
		51	m_pProfEnv->DeleteMethodsData();
		52	m_pProfEnv->m_pShadowStackTracker->TrackECAttach();
		53
		54	TResult res = m_pProfEnv->EnableSupportedEG();
		55	if (MRTE_FAILED(res))
		56	{
		57	if (MRTE_ERROR_PHASE_FAILURE == res)
		58	{
		59	LOG_DIE("Attach failed (too early)");
		60	}
		61	else
		62	{
		63	LOG_DIE("Attach failed");
		64	}
		65	}
		66
		67	return;
		68	}
		69	// Add for bug 194081
		70
48	const int MAX_THREADS = 100;	71	const int MAX_THREADS = 100;
49	const int MAX_FRAMES = 100;	72	const int MAX_FRAMES = 100;
50	TResult res;	73	TResult res;
Lines 146-152 Link Here
146		169
147	if (m_pProfEnv->m_enableDataCollection) {	170	if (m_pProfEnv->m_enableDataCollection) {
148	if (m_pProfEnv->ec_env->isStackInfoNormal()) {	171	if (m_pProfEnv->ec_env->isStackInfoNormal()) {
149	SStackTrace_ stackTrace;	172	SStackTrace_ stackTrace = {0};
150	m_pProfEnv->ConvertStackTrace(&(threadInfoArray.pEntries[i].threadInfo), &stackTrace);	173	m_pProfEnv->ConvertStackTrace(&(threadInfoArray.pEntries[i].threadInfo), &stackTrace);
151	m_pProfEnv->ec_env->PrintMonitorWaitElement(&data, &stackTrace);	174	m_pProfEnv->ec_env->PrintMonitorWaitElement(&data, &stackTrace);
152	m_pProfEnv->FreeStackTrace(&stackTrace);	175	m_pProfEnv->FreeStackTrace(&stackTrace);
Lines 161-167 Link Here
161	}	184	}
162	}	185	}
163	for (i = 0; i < MAX_THREADS; i++) {	186	for (i = 0; i < MAX_THREADS; i++) {
164	delete threadInfoArray.pEntries[i].threadInfo.vmOffsetStack.pStackEntries;	187	delete [](threadInfoArray.pEntries[i].threadInfo.vmOffsetStack.pStackEntries);
165	}	188	}
166	} else {	189	} else {
167	res = m_pProfEnv->m_pMpiApi->GetAllThreadsInfo(m_pProfEnv->m_clientId, 0, DR_THREAD_INFO, &threadInfoArray);	190	res = m_pProfEnv->m_pMpiApi->GetAllThreadsInfo(m_pProfEnv->m_clientId, 0, DR_THREAD_INFO, &threadInfoArray);

Lines 41-46 Link Here

(-)src-native/src/BaseProf/VMShutdownEvent.cpp (-1 / +11 lines)
41	if (!m_pProfEnv->m_profilerIsActive) {	41	if (!m_pProfEnv->m_profilerIsActive) {
42	return;	42	return;
43	}	43	}
44	m_pProfEnv->PrintAggCallGraph();	44	// Modified for bug 194081
		45	if (m_pProfEnv->ec_env->isCGExecDetails())
		46	{
		47	m_pProfEnv->m_pShadowStackTracker->TrackVMShutdown();
		48	}
		49	else
		50	{
		51	m_pProfEnv->PrintAggCallGraph();
		52	}
		53	// Modified for bug 194081
		54
45	m_pProfEnv->ec_env->PrintRuntimeShutdownElement();	55	m_pProfEnv->ec_env->PrintRuntimeShutdownElement();
46	}	56	}