[OpenMP] Replaced mutex lock/unlock in `target` with `std::lock_guard`

[ye-luo]

Only one minor issue. Your initial sophisticated patch made my thought you replaced all the lock/unlock. After splitting, the change becomes very clean.

openmp/libomptarget/src/omptarget.cpp

766–772

Pull nullptr initial value.

[tianshilei1992]

Initialize TargetTable`

[ye-luo]

LGTM

openmp/libomptarget/src/omptarget.cpp

 int target(int64_t DeviceId, void *HostPtr, int32_t ArgNum, void **ArgBases,
            void **Args, int64_t *ArgSizes, int64_t *ArgTypes, void **ArgMappers,
            int32_t TeamNum, int32_t ThreadLimit, int IsTeamConstruct) {
   DeviceTy &Device = Devices[DeviceId];
 
   // Find the table information in the map or look it up in the translation
   // tables.
   TableMap *TM = 0;
-  TblMapMtx->lock();
+  {
+    std::lock_guard<std::mutex> TblMapLock(*TblMapMtx);
     HostPtrToTableMapTy::iterator TableMapIt = HostPtrToTableMap->find(HostPtr);
     if (TableMapIt == HostPtrToTableMap->end()) {
       // We don't have a map. So search all the registered libraries.
-    TrlTblMtx->lock();
+      std::lock_guard<std::mutex> TrlTblLock(*TrlTblMtx);
       for (HostEntriesBeginToTransTableTy::iterator
                II = HostEntriesBeginToTransTable->begin(),
                IE = HostEntriesBeginToTransTable->end();
            !TM && II != IE; ++II) {
         // get the translation table (which contains all the good info).
         TranslationTable *TransTable = &II->second;
         // iterate over all the host table entries to see if we can locate the
         // host_ptr.
         __tgt_offload_entry *Begin = TransTable->HostTable.EntriesBegin;
         __tgt_offload_entry *End = TransTable->HostTable.EntriesEnd;
         __tgt_offload_entry *Cur = Begin;
         for (uint32_t I = 0; Cur < End; ++Cur, ++I) {
           if (Cur->addr != HostPtr)
             continue;
           // we got a match, now fill the HostPtrToTableMap so that we
           // may avoid this search next time.
           TM = &(*HostPtrToTableMap)[HostPtr];
           TM->Table = TransTable;
           TM->Index = I;
           break;
         }
       }
-    TrlTblMtx->unlock();
     } else {
       TM = &TableMapIt->second;
     }
-  TblMapMtx->unlock();
+  }
 
   // No map for this host pointer found!
   if (!TM) {
     DP("Host ptr " DPxMOD " does not have a matching target pointer.\n",
        DPxPTR(HostPtr));
     return OFFLOAD_FAIL;
   }
 
   // get target table.
-  TrlTblMtx->lock();
+  __tgt_target_table *TargetTable = nullptr;
+  {
+    std::lock_guard<std::mutex> TrlTblLock(*TrlTblMtx);
     assert(TM->Table->TargetsTable.size() > (size_t)DeviceId &&
            "Not expecting a device ID outside the table's bounds!");
-  __tgt_target_table *TargetTable = TM->Table->TargetsTable[DeviceId];
-  TrlTblMtx->unlock();
+    TargetTable = TM->Table->TargetsTable[DeviceId];
+  }
   assert(TargetTable && "Global data has not been mapped\n");
 
   __tgt_async_info AsyncInfo;
 
   // Move data to device.
   int Ret = targetDataBegin(Device, ArgNum, ArgBases, Args, ArgSizes, ArgTypes,
                             ArgMappers, &AsyncInfo);
   if (Ret != OFFLOAD_SUCCESS) {
#endif
     TgtOffsets.push_back(TgtBaseOffset);
   }
 
   assert(TgtArgs.size() == TgtOffsets.size() &&
          "Size mismatch in arguments and offsets");
 
   // Pop loop trip count
   uint64_t LoopTripCount = 0;
-  TblMapMtx->lock();
+  {
+    std::lock_guard<std::mutex> TblMapLock(*TblMapMtx);
     auto I = Device.LoopTripCnt.find(__kmpc_global_thread_num(NULL));
     if (I != Device.LoopTripCnt.end()) {
       LoopTripCount = I->second;
       Device.LoopTripCnt.erase(I);
       DP("loop trip count is %lu.\n", LoopTripCount);
     }
-  TblMapMtx->unlock();
+  }
 
   // Launch device execution.
   DP("Launching target execution %s with pointer " DPxMOD " (index=%d).\n",
      TargetTable->EntriesBegin[TM->Index].name,
      DPxPTR(TargetTable->EntriesBegin[TM->Index].addr), TM->Index);
   if (IsTeamConstruct) {
     Ret = Device.runTeamRegion(TargetTable->EntriesBegin[TM->Index].addr,
                                &TgtArgs[0], &TgtOffsets[0], TgtArgs.size(),